# USGS Real-Time Water Monitor (`bytehavenstudios/usgs-water-monitor`) Actor

Monitor US real-time streamflow, gauge height and water quality across USGS gauges. One normalized record per reading (site, parameter, value, unit, timestamp), with optional threshold alerts and a changed-since-last-run mode. USGS data, U.S. public domain.

- **URL**: https://apify.com/bytehavenstudios/usgs-water-monitor.md
- **Developed by:** [ByteHaven Studios](https://apify.com/bytehavenstudios) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 reading returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## USGS Real-Time Water Monitor

Monitor **US real-time streamflow, gauge height, and water-quality** across USGS gauges.
Give it a list of USGS site numbers and parameter codes; it returns one normalized record per
reading, with optional **threshold-crossed alerts** and a **changed-since-last-run** monitoring mode.

Clean REST/JSON — no browser, no proxy, no login. **Data source: USGS (U.S. public domain).**

---

### What it does

For each run it queries the USGS **WaterServices Instantaneous Values (IV)** service for your sites +
parameters, normalizes the response, applies your filters, and pushes one dataset item per reading.

- **Latest snapshot** (default): the most recent reading per site+parameter.
- **Look-back window**: set `period` (e.g. `P1D`, `PT6H`) to return every reading in that window.
- **Since a date**: `sinceDate` returns only readings on/after an instant.
- **Change monitor**: `monitorChangesOnly` persists the last-seen timestamp per series (in the
  Actor's key-value store) and, on the next scheduled run, returns only *new* readings.
- **Threshold alerts**: `thresholds` attaches an `alert` object to readings that cross an
  `above`/`below` bound; `onlyAlerts` returns just the crossings.

### Inputs

| Input | Type | Notes |
|---|---|---|
| `sites` (required) | string[] | USGS site numbers, e.g. `01646500` (Potomac @ Washington DC) |
| `parameterCodes` | string[] | e.g. `00060` discharge, `00065` gauge height, `00010` water temp |
| `period` | string | ISO-8601 duration, e.g. `P1D`. Empty = latest reading only |
| `sinceDate` | string | Return readings on/after this ISO datetime |
| `monitorChangesOnly` | boolean | Return only readings newer than the previous run |
| `thresholds` | object[] | `[{ "site":"01646500","parameterCode":"00065","above":10,"below":1 }]` |
| `onlyAlerts` | boolean | Return only threshold-crossing readings |
| `maxResultsPerSite` | integer | Cap readings per site (0 = no cap) |
| `apiKey` | string (secret) | Not needed today; reserved for the 2027 API cutover |
| `proxyConfiguration` | object | Optional; the API is open and needs no proxy. Default: none |

### Output — one record per reading

```json
{
  "site": "01646500",
  "siteName": "POTOMAC RIVER NEAR WASH, DC LITTLE FALLS PUMP STA",
  "agencyCode": "USGS",
  "latitude": 38.94977778,
  "longitude": -77.12763889,
  "parameterCode": "00060",
  "parameterName": "Streamflow, ft³/s",
  "unit": "ft3/s",
  "methodId": 69928,
  "value": 5500,
  "valueRaw": "5500",
  "qualifiers": ["P"],
  "dateTime": "2026-07-09T17:50:00.000-04:00",
  "isNew": true,
  "alert": { "type": "threshold-crossed", "direction": "above", "threshold": 5000, "value": 5500 },
  "source": "waterservices-iv",
  "fetchedAt": "2026-07-09T22:15:00.000Z"
}
````

`value` is numeric (USGS no-data sentinel `-999999` is mapped to `null`). `qualifiers` `["P"]` =
provisional data (subject to revision). `isNew` is `true` when a reading is newer than the previous
run's watermark (only meaningful with `monitorChangesOnly`). `alert` is present only on
threshold-crossing readings.

#### Control records (not charged)

Two non-reading records may be pushed to signal run state. Neither triggers a `reading-returned`
charge:

| Record | When | Shape |
|---|---|---|
| `_noData` | USGS returned no readings for the requested sites/parameters (bad site number, inactive gauge, or empty window) | `{ "_noData": true, "sites": [...], "parameterCodes": [...], "message": "...", "fetchedAt": "..." }` |
| `_error` | The fetch failed after retries, or normalization threw | `{ "_error": true, "sites": [...], "parameterCodes": [...], "message": "...", "fetchedAt": "..." }` |

`_noData` keeps a zero-result run green and auditable rather than pushing a silent empty dataset.

### Pricing (pay-per-event)

One **`reading-returned`** event is charged per record pushed to the dataset — including alert
records. Cost scales with results, not runtime. Use `onlyAlerts` / `maxResultsPerSite` /
`monitorChangesOnly` to keep spend proportional to signal.

### Data source & attribution

Data © nobody — **U.S. public domain**, courtesy of the **U.S. Geological Survey** (USGS Water Data
for the Nation). No key and no attribution are required; we credit USGS as a courtesy. Provisional
data are subject to revision (see the `P` qualifier). Full compliance record: [`COMPLIANCE.md`](./COMPLIANCE.md).

### ⚠️ Maintenance obligation — 2027 API migration

The USGS **WaterServices** APIs this Actor uses are **being decommissioned in Q1 2027** (intentional
degradation not before Aug 2026). The replacement is **`https://api.waterdata.usgs.gov`**. The
GeoJSON parser for the new API is already in `src/usgs.js` (`normalizeNewApiItems`), but its data
lives behind a path that `robots.txt` currently disallows for bots — cutover must use the
documented, API-key'd path and re-verify robots.txt at that time. **Complete the cutover before
Q1 2027.** See [`COMPLIANCE.md`](./COMPLIANCE.md) §3–§4.

# Actor input Schema

## `sites` (type: `array`):

USGS site numbers (station IDs) to monitor. Find them at https://waterdata.usgs.gov/ or https://dashboard.waterdata.usgs.gov/. Example: 01646500 = Potomac River near Washington, DC.

## `parameterCodes` (type: `array`):

USGS 5-digit parameter codes to fetch. 00060 = discharge / streamflow (ft³/s), 00065 = gauge height (ft), 00010 = water temperature (°C), 00300 = dissolved oxygen. Full list: https://help.waterdata.usgs.gov/codes-and-parameters/parameters

## `period` (type: `string`):

Optional. Return all readings within this trailing period, e.g. P1D (last day), PT6H (last 6 hours). Leave empty to return only the single LATEST reading per site+parameter (cheapest, best for monitoring).

## `sinceDate` (type: `string`):

Monitoring mode: return only readings whose timestamp is on/after this instant. Accepts YYYY-MM-DD or a full ISO-8601 datetime. Ignored if 'Only changed since last run' is on.

## `monitorChangesOnly` (type: `boolean`):

Persist the last-seen timestamp per site+parameter (in the Actor's key-value store) and, on the next run, return only readings newer than what was already reported. Turns this Actor into a change monitor across scheduled runs.

## `thresholds` (type: `array`):

Per site+parameter alert rules. Each item: { "site": "01646500", "parameterCode": "00065", "above": 10, "below": 1 }. A reading whose value exceeds 'above' or falls under 'below' gets an 'alert' object attached. Use 'onlyAlerts' to return alerts exclusively.

## `onlyAlerts` (type: `boolean`):

When on, only readings that crossed one of the 'thresholds' are returned (and charged). Off = every reading is returned.

## `maxResultsPerSite` (type: `integer`):

Cap the number of readings returned per site (across all parameters). 0 = no cap.

## `apiKey` (type: `string`):

Optional. Not needed today (WaterServices requires no key). Reserved for the api.waterdata.usgs.gov cutover, where a free key (https://api.waterdata.usgs.gov/signup) raises rate limits. Stored as a secret.

## `proxyConfiguration` (type: `object`):

Optional. The USGS API is a clean, open, public endpoint and needs NO proxy. You may enable Apify Proxy only to distribute requests if you monitor a very large number of sites. Default: no proxy.

## Actor input object example

```json
{
  "sites": [
    "01646500"
  ],
  "parameterCodes": [
    "00060",
    "00065"
  ],
  "period": "P1D",
  "sinceDate": "2026-07-09",
  "monitorChangesOnly": false,
  "thresholds": [],
  "onlyAlerts": false,
  "maxResultsPerSite": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `readings` (type: `string`):

One normalized reading per item (site, parameter, value, unit, timestamp), plus any threshold alert. Rendered as the Readings table (see the dataset schema).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sites": [
        "01646500"
    ],
    "parameterCodes": [
        "00060",
        "00065"
    ],
    "thresholds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("bytehavenstudios/usgs-water-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sites": ["01646500"],
    "parameterCodes": [
        "00060",
        "00065",
    ],
    "thresholds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("bytehavenstudios/usgs-water-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sites": [
    "01646500"
  ],
  "parameterCodes": [
    "00060",
    "00065"
  ],
  "thresholds": []
}' |
apify call bytehavenstudios/usgs-water-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bytehavenstudios/usgs-water-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Real-Time Water Monitor",
        "description": "Monitor US real-time streamflow, gauge height and water quality across USGS gauges. One normalized record per reading (site, parameter, value, unit, timestamp), with optional threshold alerts and a changed-since-last-run mode. USGS data, U.S. public domain.",
        "version": "0.1",
        "x-build-id": "4cRfljcB4NIX8Uy6w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bytehavenstudios~usgs-water-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bytehavenstudios-usgs-water-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bytehavenstudios~usgs-water-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bytehavenstudios-usgs-water-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bytehavenstudios~usgs-water-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bytehavenstudios-usgs-water-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sites"
                ],
                "properties": {
                    "sites": {
                        "title": "USGS site / gauge numbers",
                        "type": "array",
                        "description": "USGS site numbers (station IDs) to monitor. Find them at https://waterdata.usgs.gov/ or https://dashboard.waterdata.usgs.gov/. Example: 01646500 = Potomac River near Washington, DC.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "parameterCodes": {
                        "title": "Parameter codes",
                        "type": "array",
                        "description": "USGS 5-digit parameter codes to fetch. 00060 = discharge / streamflow (ft³/s), 00065 = gauge height (ft), 00010 = water temperature (°C), 00300 = dissolved oxygen. Full list: https://help.waterdata.usgs.gov/codes-and-parameters/parameters",
                        "items": {
                            "type": "string"
                        }
                    },
                    "period": {
                        "title": "Look-back period (ISO-8601 duration)",
                        "type": "string",
                        "description": "Optional. Return all readings within this trailing period, e.g. P1D (last day), PT6H (last 6 hours). Leave empty to return only the single LATEST reading per site+parameter (cheapest, best for monitoring)."
                    },
                    "sinceDate": {
                        "title": "Only readings on/after (ISO datetime)",
                        "type": "string",
                        "description": "Monitoring mode: return only readings whose timestamp is on/after this instant. Accepts YYYY-MM-DD or a full ISO-8601 datetime. Ignored if 'Only changed since last run' is on."
                    },
                    "monitorChangesOnly": {
                        "title": "Only changed since last run",
                        "type": "boolean",
                        "description": "Persist the last-seen timestamp per site+parameter (in the Actor's key-value store) and, on the next run, return only readings newer than what was already reported. Turns this Actor into a change monitor across scheduled runs.",
                        "default": false
                    },
                    "thresholds": {
                        "title": "Alert thresholds",
                        "type": "array",
                        "description": "Per site+parameter alert rules. Each item: { \"site\": \"01646500\", \"parameterCode\": \"00065\", \"above\": 10, \"below\": 1 }. A reading whose value exceeds 'above' or falls under 'below' gets an 'alert' object attached. Use 'onlyAlerts' to return alerts exclusively."
                    },
                    "onlyAlerts": {
                        "title": "Return only threshold-crossing readings",
                        "type": "boolean",
                        "description": "When on, only readings that crossed one of the 'thresholds' are returned (and charged). Off = every reading is returned.",
                        "default": false
                    },
                    "maxResultsPerSite": {
                        "title": "Max readings per site",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of readings returned per site (across all parameters). 0 = no cap.",
                        "default": 0
                    },
                    "apiKey": {
                        "title": "USGS API key (optional)",
                        "type": "string",
                        "description": "Optional. Not needed today (WaterServices requires no key). Reserved for the api.waterdata.usgs.gov cutover, where a free key (https://api.waterdata.usgs.gov/signup) raises rate limits. Stored as a secret."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The USGS API is a clean, open, public endpoint and needs NO proxy. You may enable Apify Proxy only to distribute requests if you monitor a very large number of sites. Default: no proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
