diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 92ce50a..a0eb52f 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -72,3 +72,12 @@ updates: update-types: - "minor" - "patch" + - package-ecosystem: "npm" + directory: "/" + schedule: + interval: "weekly" + groups: + minor-and-patch: + update-types: + - "minor" + - "patch" diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 41319cb..72ddcc5 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -14,3 +14,15 @@ jobs: run-tests: true run-cdk-synth: true run-sam-validate: false + # The published OpenAPI contract must stay compliant with redocly.yaml; + # this is the CI mirror of the local `npm run lint:api`. + spec-lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0 + with: + node-version: 22 + cache: npm + - run: npm ci + - run: npm run lint:api diff --git a/.redocly.lint-ignore.yaml b/.redocly.lint-ignore.yaml new file mode 100644 index 0000000..3d3cd33 --- /dev/null +++ b/.redocly.lint-ignore.yaml @@ -0,0 +1,17 @@ +# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API. +# See https://redocly.com/docs/cli/ for more information. +# +# operation-2xx-response: the two x-planned phase-2 write endpoints answer +# ONLY 501 until built -- documenting a 2xx they cannot return would lie. +# paths-kebab-case: webhook keys are the shipped SHOC contract event names +# (docs/shoc-webhook-contract.md Rev 2026-07-23, event_type enum) -- not +# renameable without a contract break. +lambdas/api/openapi.json: + operation-2xx-response: + - '#/paths/~1work-orders~1{workOrderId}/patch/responses' + - '#/paths/~1work-orders~1{workOrderId}~1comments/post/responses' + paths-kebab-case: + - '#/webhooks/work_order.created' + - '#/webhooks/work_order.updated' + - '#/webhooks/work_order.cancelled' + - '#/webhooks/work_order.comment_added' diff --git a/README.md b/README.md index d55ab78..a493270 100644 --- a/README.md +++ b/README.md @@ -86,9 +86,28 @@ Amazon APM work order emails (from Hexagon EAM / HxGN SmartCloud) are received a - `WorkOrders` (PK: `work_order_id`) — `site-code-index` and `status-index` GSIs removed 2026-06-03 (audit M-20) - `WorkOrderComments` (PK: `work_order_id`, SK: `comment_id`) — see the `comment_id` format note below +### Procurement API (`procurement-api` stack) + +A read-only REST API (API Gateway + the `procurement-api` Lambda, `lambdas/api/`) over both pipelines' tables, plus a token-gated OpenAPI docs page. Primary consumer: the SHOC backend, for which this replaces the retired SyncController cross-account DynamoDB scan as the reconciliation/backfill path (and the initial-history load for the outbound work-order webhook, which starts at LATEST). + +| Method + path | Auth | Backing read | +|---|---|---| +| `GET /work-orders` · `/purchase-orders` · `/verified-sites` | IAM SigV4 | unordered paginated Scan (`limit` 1–500, opaque `cursor` = base64 `LastEvaluatedKey`; malformed cursor → 400) | +| `GET /work-orders/{id}` · `/purchase-orders/{id}` · `/verified-sites/{siteCode}` | IAM SigV4 | GetItem (404 on miss) | +| `GET /work-orders/{id}/comments` | IAM SigV4 | Query on the partition key, paginated | +| `POST /work-orders/{id}/comments`, `PATCH /work-orders/{id}` | — | **phase-2 planned** (`x-planned` in the spec); handler answers 501 | +| `GET /docs`, `GET /openapi.json` | shared docs token (`X-Auth-Token` header or `?token=` in a browser) | Redoc reference docs (vendored offline, no CDN) with the spec inlined / the committed spec | + +- **Spec is source of truth:** `lambdas/api/openapi.json` (OpenAPI 3.1). Its top-level `webhooks` section documents the outbound SHOC work-order feed, so one page describes both directions (call + be-called). `tests/test_api_spec_drift.py` pins the spec's paths to the router table, so spec and implementation cannot drift. +- **Auth:** data routes use API Gateway `AWS_IAM` (SigV4) plus a resource policy allowing exactly `arn:aws:iam::396287094661:role/shoc-backend-dev` on `GET/*`; same-account admin callers authorize via identity policy (Postman signs SigV4 natively). Docs routes are auth `NONE` at the gateway (resource-policy carve-out for exactly those two GETs) but the handler fails closed on the shared token (`lambdas/shared/web_ui_auth.py`, secret `procurement-ingest/web-ui-auth-token`) — not an unauthenticated data path (INFRA-74 posture). +- **KMS:** `purchase-orders` is CMK-encrypted; the imported-by-name table doesn't carry the key association, so the stack grants `kms:Decrypt`/`DescribeKey` on the CMK from SSM `/seahaven/dynamodb/cmk-arn` explicitly (the INFRA-104 failure class). +- **No access logging in v1** (keeps the `?token=` shim out of any log and avoids the account-level API Gateway CloudWatch role); rotate the docs token before ever enabling it. No CORS (server-to-server + Postman callers). +- **Alarms:** `procurement-api-errors`/`-throttles`/`-duration` (p99 ≥ 22.5 s) + gateway `procurement-api-5xx`, all ALARM-only → `site-alerts`. No 4XX alarm (401/403/404 are expected traffic). +- **Docs page:** `/docs` serves Redoc (read-only reference docs; live calls go through Postman since data routes need SigV4) as ONE token-gated response: the handler inlines the vendored `redoc.standalone.js`, the design-system fonts (`fonts.css`, data-URI `@font-face` — nothing may fetch from Google Fonts, test-pinned), and the spec into `docs.html`, with ``/`` breakout guards on every blob. Theme = SHOC tokens (Montserrat/DM Sans/JetBrains Mono, primary `#1c75bc`, 64px gradient topbar). The right-panel gradient and the topbar's Hide/Show-samples toggle target styled-components class names that are deterministic for the pinned Redoc bundle but change on any bump — re-derive them then (headless probe: elements whose computed background equals the `rightPanel` color); stale selectors degrade to a solid panel / inert toggle, cosmetic only. Tooling: `npm run lint:api` lints the spec against `redocly.yaml` (CI job `spec-lint`; deliberate exceptions live in `.redocly.lint-ignore.yaml`), `npm run docs:preview` renders the real handler output locally. + ## Architecture -**IaC:** AWS CDK (Python), two stacks in one app, region `us-east-1`. The `cdk.Environment` is deliberately **account-agnostic** (region-only, no `account=`): the stacks deploy to whichever account the deploy credentials target (`011934824531` seahaven-prod since the 2026-07 account migration; formerly mgmt `328440206208`), and every account-derived template value — bucket names, `Lambda::Permission` source account, the site-alerts SNS action ARN, the Bedrock ARN below — renders as the CloudFormation `AWS::AccountId` pseudo-parameter rather than a literal. Pinning `account=` was evaluated in Phase 4 and rejected: it would resolve those tokens to literals, and against the deployed (account-agnostic) templates CloudFormation flags the `RemovalPolicy.RETAIN` email buckets as requiring replacement — a data-loss risk — for no functional gain. +**IaC:** AWS CDK (Python), three stacks in one app, region `us-east-1`. The `cdk.Environment` is deliberately **account-agnostic** (region-only, no `account=`): the stacks deploy to whichever account the deploy credentials target (`011934824531` seahaven-prod since the 2026-07 account migration; formerly mgmt `328440206208`), and every account-derived template value — bucket names, `Lambda::Permission` source account, the site-alerts SNS action ARN, the Bedrock ARN below — renders as the CloudFormation `AWS::AccountId` pseudo-parameter rather than a literal. Pinning `account=` was evaluated in Phase 4 and rejected: it would resolve those tokens to literals, and against the deployed (account-agnostic) templates CloudFormation flags the `RemovalPolicy.RETAIN` email buckets as requiring replacement — a data-loss risk — for no functional gain. All Lambdas: Python 3.12, ARM64, 60-day log retention. @@ -179,7 +198,7 @@ if isinstance(event, dict) and event.get("healthcheck") is True: This placement is deliberate, not incidental: real mail always arrives as an S3 `ObjectCreated` event whose top-level keys (`Records`) AWS controls, so email content can never set a top-level `healthcheck` key — the branch creates no accept path for forged mail. It also emits **no EMF metric and no log line**, so it can never match the `sender_auth_rejected` log-metric-filter pattern that feeds the `-sender-auth-rejected` alarm (see [CloudWatch alarms](#cloudwatch-alarms)) — that alarm pages at ≥1 match in its window, so repeated healthcheck invokes across deploys (two deploys in ~30 min is routine) must never contribute to it. Unit coverage: `lambdas/po/email_processor/tests/test_po_healthcheck.py` and `lambdas/wo/email_processor/tests/test_healthcheck.py`. -**Post-deploy smoke gate.** `scripts/post-deploy-smoke.sh` is wired into the CD workflow as `cd-cdk.yaml`'s `post-deploy-script` input (see [CI/CD](#cicd)) and runs synchronously after every deploy, before the workflow is considered green. It invokes both `po-email-processor` and `workorder-email-processor` with `aws lambda invoke --invocation-type RequestResponse --payload '{"healthcheck": true}'` (region `us-east-1`) and asserts, per function: +**Post-deploy smoke gate.** `scripts/post-deploy-smoke.sh` is wired into the CD workflow as `cd-cdk.yaml`'s `post-deploy-script` input (see [CI/CD](#cicd)) and runs synchronously after every deploy, before the workflow is considered green. It invokes `po-email-processor`, `workorder-email-processor`, and `procurement-api` with `aws lambda invoke --invocation-type RequestResponse --payload '{"healthcheck": true}'` (region `us-east-1`) and asserts, per function: 1. The invoke response's **`FunctionError` field is absent** — this is the load-bearing check. A broken bundle (e.g. an `ImportError` at module init from a missing sibling module) still returns HTTP 200 from the Lambda Invoke API with `FunctionError=Unhandled`; a bare exit-code check on `aws lambda invoke` would false-pass on exactly the failure this gate exists to catch. 2. The returned payload is **exactly** `{"healthcheck": "ok"}`. @@ -248,13 +267,13 @@ The `purchase-orders` DynamoDB table is **owned by this repo's `po-ingest` stack **Consumers (read-only):** -| Repo | How it reads | Purpose | +| Consumer | How it reads | Purpose | |---|---|---| -| `seahaven-slack-bot` | `po-sync` (DynamoDB Streams + daily scan) and `wo-po-lookup` | Daily KB sync + Bedrock agent PO lookups | +| `procurement-api` (this repo) | `Table.from_table_name` + `grant_read_data` | REST reads (`GET /purchase-orders*`) | -The consumer imports the table via `Table.fromTableName(...)` and is granted read-only access (`grantReadData`); it does not own or define it. +`seahaven-slack-bot`, the former external consumer, was decommissioned 2026-07-23 and its cross-account grants removed. External consumers now read through the `procurement-api` REST contract (`lambdas/api/openapi.json`), never by importing the table directly. -**Schema-coordination rule:** Any change to the `purchase-orders` schema (partition key, item shape, attribute names, streams view type) must be coordinated with `seahaven-slack-bot`. The owner here ships the change; the consumer must be updated in lockstep so its readers do not break. Treat schema changes as a cross-repo migration, not a local edit. +**Schema-coordination rule:** Any change to the `purchase-orders` schema (partition key, item shape, attribute names, streams view type) must be reflected in the API's OpenAPI schemas in the same PR (the spec-drift test pins paths, not item shapes — the schema fields are maintained by hand). Treat schema changes as a contract migration, not a local edit. **Known exception (INFRA-51):** `amazon-po-parser` currently writes directly to `purchase-orders` outside this stack (backfill/enrichment scripts). This second writer is being folded into the `po-ingest` pipeline so this stack is the sole writer; until INFRA-51 closes, coordinate any schema change with `amazon-po-parser` as well. @@ -284,7 +303,7 @@ Both tables are **owned by this repo's `WorkorderIngestStack`** (`cdk/wo_stack.p Both currently use default DynamoDB encryption — they are **not** yet on the shared customer-managed CMK (`alias/seahaven-dynamodb`, INFRA-95 / M-3); that migration is tracked in INFRA-6. The `workorder-email-processor` role no longer holds a pre-emptive encrypt/decrypt grant on that CMK (removed in the 2026-06-17 security sweep — it was unused while the tables are unencrypted and extended the role's decrypt reach to the CMK protecting `purchase-orders`). Re-add the grant as part of the INFRA-6 migration, at which point `grant_read_write_data` on the then-encrypted tables propagates the needed key permissions automatically. -**Consumer (read-only) — data contract:** `seahaven-slack-bot` imports both tables via `Table.fromTableName(...)` (`grantReadData`) and reads them from two Lambdas: `workorder-sync` (daily full-table scan into the Bedrock knowledge base) and `wo-po-lookup` (the Bedrock agent's direct WO lookup action group). The bot depends on the PK/SK schema above and these attributes: on `WorkOrders` — `description`, `wo_status`, `customer`, `site_code`, `building`, `address`, `severity`, `priority`, `assigned_to`, `date_reported`, `scheduled_start`, `due_date`, `updated_at`; on `WorkOrderComments` — `created_at` (used to sort comments), `commenter`, `text`. Any change to table name, key schema, these attribute names, or the encryption configuration (e.g. the INFRA-6 CMK migration) must be coordinated with `seahaven-slack-bot` before it ships, or the Bedrock agent breaks at runtime (not at deploy — the tables are imported by name, so there is no compile-time link). +**Consumers (read-only) — data contract:** `seahaven-slack-bot` (the former external reader) was decommissioned 2026-07-23; its grants are gone. Current consumers: the `procurement-api` Lambda (this repo, `Table.from_table_name` + `grant_read_data`, serving `GET /work-orders*`), and — once the SHOC webhook ships — the `workorder-shoc-emitter` stream consumer. External readers (SHOC) consume through the REST contract (`lambdas/api/openapi.json`) and the webhook contract (`docs/shoc-webhook-contract.md`); both documents' field lists mirror `lambdas/wo/email_processor/persistence.py`. Any change to table name, key schema, attribute names, or encryption configuration (e.g. the INFRA-6 CMK migration) must update those two contracts in the same PR — the tables are imported by name, so there is no compile-time link and breakage surfaces at runtime. **Stream field contract (`site_code`).** Three definitions of "is this a valid site code" have existed in this repo at once. The canonical shape is `derived_fields._STRICT_CODE_RE` (`[A-Z][A-Z0-9]{2,4}`, `fullmatch`) plus its skip-list semantics (a code-shaped token is only a real site code if it is *not* skip-listed, e.g. `LLC`/`INC`/`CORP`/`LTD`/`ATTN`), used by `derive_site_code()` (the `enrich_parsed()` classifier, see the **Derived fields** note in the Purchase Orders flow above). Honestly noted, not papered over: `lambdas/po/site_extractor/handler.py`'s own `SITE_CODE_PATTERN` (`[A-Z]{2,4}\d{1,2}`, prefix-anchored `.match`, digit-requiring) still diverges from the canonical shape as of this phase — it rejects valid all-letter codes like `KLAL` (which surface as permanent `pending-site-review` rows) and accepts overlong junk like `DLI6X`/`SNY55` that the canonical `fullmatch` would not. Reconciling `po-ingest-site-extractor`'s direct-field validation onto the canonical `derived_fields` shape is Phase 6 scope, tracked separately — this paragraph will be updated when it lands. @@ -292,9 +311,7 @@ Both currently use default DynamoDB encryption — they are **not** yet on the s Owned by this repo's `po-ingest` stack (`cdk/po_stack.py`). PK `siteCode` (S); default DynamoDB encryption (NOT the shared CMK). -**Consumer (read-only) — data contract:** `seahaven-slack-bot`'s `wo-po-lookup` Lambda imports this table via `Table.fromTableName(...)` for the Bedrock agent's `lookup_site` action. It does point lookups by `siteCode` and reads `address`, `fullAddress`, `city`, `state`, `zip`, `latitude`, `longitude`, `notes`. Coordinate any change to the table name, key schema, or these attribute names with `seahaven-slack-bot`. - -> **GSI drift (INFRA-138):** the `by-state` GSI was removed here on 2026-06-03 (audit M-20, "0 reads in 30d"), but `seahaven-slack-bot` still queries `IndexName: 'by-state'` for its state-listing path, so that path fails at runtime today. Restoring the GSI or removing the consumer's state path needs to be reconciled cross-repo. This is the kind of silent owner-side lifecycle change this data-contract note exists to prevent. +**Consumer (read-only) — data contract:** `seahaven-slack-bot` (former reader, incl. the INFRA-138/INFRA-180 `by-state` GSI drift saga) was decommissioned 2026-07-23 — the GSI-drift issue died with it. Current consumer: the `procurement-api` Lambda (`GET /verified-sites*`). The API's `VerifiedSite` schema deliberately promises only pipeline-written fields (`siteCode`, `address`, `city`, `state`, `zip`, `fullAddress`, `locationCode`, `poCount`, `sourcePOs`) — `latitude`/`longitude`/`notes` were manually curated legacy attributes the extractor never writes, and are not part of the contract. ## Documentation @@ -306,7 +323,7 @@ The canonical map of Sea Haven's AWS infrastructure lives in Confluence. This pr GitHub Actions with reusable workflows from `Sea-Haven-Industries/.github` (all pinned to a commit SHA of `main`): - **CI** (`ci.yaml`, PR to `main`): linting + `cdk synth` via `ci-python-sam.yaml`. `cdk synth`'s Docker-bundled asset build for `po-email-processor` and `workorder-email-processor` mounts the widened `../lambdas` asset root (Phase 2, see [Deploy-Pipeline Guards](#deploy-pipeline-guards-phase-0)) as build context, not just each function's own subdirectory — the `exclude` list on both `from_asset` calls strips local-only `__pycache__`/`package/` (and `tests/`) cruft from that wider mount's source fingerprint, so CI's asset hash matches a clean local checkout, and each function's scoped `cp` glob copies only its own pipeline's `*.py` into the zip. (The exclude does not, and under `SOURCE` hashing cannot, keep the *other* pipeline's tracked source out of the fingerprint (see the PO bundling note above on `SOURCE` hashing) — but that source is identical in CI and local, so it does not cause hash divergence.) -- **CD** (`deploy.yaml`, push to `main`): CDK deploy via `cd-cdk.yaml` (OIDC auth), followed by the synchronous `post-deploy-script: scripts/post-deploy-smoke.sh` healthcheck gate (see [Deploy-Pipeline Guards](#deploy-pipeline-guards-phase-0)) — `cd-cdk.yaml`'s `stack-name` input only accepts one stack, so the smoke script itself enumerates both `po-email-processor` and `workorder-email-processor` +- **CD** (`deploy.yaml`, push to `main`): CDK deploy via `cd-cdk.yaml` (OIDC auth), followed by the synchronous `post-deploy-script: scripts/post-deploy-smoke.sh` healthcheck gate (see [Deploy-Pipeline Guards](#deploy-pipeline-guards-phase-0)) — `cd-cdk.yaml`'s `stack-name` input only accepts one stack, so the smoke script itself enumerates `po-email-processor`, `workorder-email-processor`, and `procurement-api` - Plus dependency review and PR labeler workflows on every PR Branch protection on `main` — all changes through PR. @@ -392,12 +409,13 @@ python scripts/backfill_sites.py ``` cdk/ - app.py # Two stacks: po-ingest + WorkorderIngestStack (region-only env) + app.py # Three stacks: po-ingest + WorkorderIngestStack + procurement-api (region-only env) common.py # Phase 4: shared plain-function CDK helpers (alarms, Bedrock grant, # email bucket, processor DLQ, fallback-rate alarm) -- called with # each stack's own scope + literal construct ids, logical-ID-safe po_stack.py # Purchase order pipeline resources wo_stack.py # Work order pipeline resources + procurement_api_stack.py # REST API (IAM SigV4 + resource policy) over both pipelines' tables + token-gated /docs lambdas/ # Phase 2: shared Code.from_asset("../lambdas") bundling root for # BOTH po-email-processor and workorder-email-processor (and, since # Phase 3, both web_ui functions) -- each email-processor command @@ -408,9 +426,20 @@ lambdas/ # Phase 2: shared Code.from_asset("../lambdas") bundling shared/ # Phase 3: single-sourced first-party modules, landed FLAT (no # __init__.py -- bare-name imports) into each bundle by the cp above ses_auth.py # fail-closed SES sender-auth (INFRA-107) -- one copy, one fix - web_ui_auth.py # fail-closed X-Auth-Token gate + token cache (INFRA-74) + web_ui_auth.py # fail-closed X-Auth-Token gate + token cache (INFRA-74; also gates the API /docs routes) email_parsing.py # parse_raw_email (WO superset; returns cc unconditionally) emf.py # generic CloudWatch EMF emitter (dimension-sets pinned once) + api/ # procurement-api Lambda (REST reads over both pipelines' tables) + handler.py # healthcheck early-return + docs-token gate + route dispatch + error mapping + router.py # single route table (spec-drift test pins it to openapi.json) + pagination.py # opaque base64(LastEvaluatedKey) cursor encode/validate (hostile cursor -> 400) + serialization.py # Decimal-safe JSON responses + wo_repo.py # WorkOrders/WorkOrderComments reads (paginated Scan / PK Query) + po_repo.py # purchase-orders/verified-sites reads (no VendorReplies -- dead table) + openapi.json # OpenAPI 3.1 source of truth (paths + outbound `webhooks` section) + docs.html # Redoc shell, SHOC design-system theme; handler inlines bundle/fonts/spec at request time (single token-gated request, no CDN) + redoc.standalone.js # vendored Redoc bundle (redoc 2.5.3, MIT), inlined into /docs; read-only docs, no try-it-out + fonts.css # SHOC fonts (DM Sans/Montserrat/JetBrains Mono, @fontsource latin subsets) as data URIs, inlined into /docs po/ # PO pipeline Lambdas email_processor/ # Phase 5: God-handler decomposed into flat siblings (bare-name # imports; the Phase 0/2/3 `cp /email_processor/*.py` @@ -460,7 +489,7 @@ lambdas/ # Phase 2: shared Code.from_asset("../lambdas") bundling scripts/ reprocess.py backfill_sites.py - post-deploy-smoke.sh # CD gate: synchronous healthcheck invoke of both processors, checks FunctionError + post-deploy-smoke.sh # CD gate: synchronous healthcheck invoke of the three smoke-gated functions, checks FunctionError conftest.py # Phase 8: THE repo-root session-invariant conftest. rootdir is pinned by # pytest.ini at repo root, so this loads for every pytest invocation shape -- # including a standalone `pytest lambdas/po/email_processor/tests` -- before diff --git a/cdk/app.py b/cdk/app.py index 6f237be..f1289ab 100644 --- a/cdk/app.py +++ b/cdk/app.py @@ -1,6 +1,7 @@ #!/usr/bin/env python3 import aws_cdk as cdk from po_stack import PoIngestStack +from procurement_api_stack import ProcurementApiStack from wo_stack import WorkorderIngestStack app = cdk.App() @@ -19,4 +20,11 @@ WorkorderIngestStack( env=cdk.Environment(region="us-east-1"), ) +ProcurementApiStack( + app, + "procurement-api", + stack_name="procurement-api", + env=cdk.Environment(region="us-east-1"), +) + app.synth() diff --git a/cdk/procurement_api_stack.py b/cdk/procurement_api_stack.py new file mode 100644 index 0000000..221b6ee --- /dev/null +++ b/cdk/procurement_api_stack.py @@ -0,0 +1,364 @@ +"""procurement-api stack: read-only REST API over both pipelines' tables. + +Third stack in the app. Serves work orders + comments (WO stack tables) and +purchase orders + verified sites (PO stack tables) to SigV4 callers -- the +primary consumer is the SHOC backend, for which this API replaces the retired +SyncController cross-account DynamoDB scan as the reconciliation/backfill +path. Also hosts the token-gated OpenAPI docs page (/docs, /openapi.json). + +Tables are imported by fixed physical name (Table.from_table_name), NOT +passed as cross-stack objects: object passing would synthesize CFN Exports +from the owning stacks and lock them against future changes to the tables. +The one thing name-import does NOT carry is the purchase-orders CMK +association -- see the explicit KMS grant below. +""" + +import aws_cdk as cdk +from aws_cdk import ( + Duration, + Stack, + aws_apigateway as apigateway, + aws_cloudwatch as cloudwatch, + aws_cloudwatch_actions as cw_actions, + aws_dynamodb as dynamodb, + aws_iam as iam, + aws_kms as kms, + aws_lambda as lambda_, + aws_secretsmanager as secretsmanager, + aws_sns as sns, + aws_ssm as ssm, +) +from constructs import Construct + +import common + +# The only cross-account caller. Grants are to this exact role ARN -- future +# shoc-backend-staging/-prod roles are each a deliberate, individually +# cross-reviewed addition (no wildcard/prefix trust). +SHOC_BACKEND_DEV_ROLE_ARN = "arn:aws:iam::396287094661:role/shoc-backend-dev" + +STAGE_NAME = "prod" + + +class ProcurementApiStack(Stack): + def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: + super().__init__(scope, construct_id, **kwargs) + + alarm_topic = sns.Topic.from_topic_arn( + self, + "SiteAlertsTopic", + f"arn:aws:sns:{self.region}:{self.account}:site-alerts", + ) + + work_orders_table = dynamodb.Table.from_table_name( + self, "WorkOrdersTable", "WorkOrders" + ) + comments_table = dynamodb.Table.from_table_name( + self, "CommentsTable", "WorkOrderComments" + ) + po_table = dynamodb.Table.from_table_name( + self, "PurchaseOrdersTable", "purchase-orders" + ) + verified_sites_table = dynamodb.Table.from_table_name( + self, "VerifiedSitesTable", "verified-sites" + ) + + web_ui_auth_secret = secretsmanager.Secret.from_secret_name_v2( + self, + "WebUiAuthToken", + "procurement-ingest/web-ui-auth-token", + ) + + # purchase-orders is SSE-KMS encrypted with the org DynamoDB CMK. A + # name-imported Table has no encryption-key association, so + # grant_read_data alone leaves the reader without kms:Decrypt and every + # purchase-orders read AccessDenies at runtime (the INFRA-104 failure + # class). Import the key from the same SSM parameter po_stack uses and + # grant it explicitly. + dynamodb_cmk = kms.Key.from_key_arn( + self, + "DynamoDbCmk", + ssm.StringParameter.value_for_string_parameter( + self, "/seahaven/dynamodb/cmk-arn" + ), + ) + + # RETAIN log group (INFRA-114). This is the only stateful resource in + # this otherwise-stateless stack, so it carries the fresh-deploy + # rollback trap: if the FIRST create fails after the group exists, + # rollback deletes everything else but retains the group, and the retry + # CREATE then collides on "/aws/lambda/procurement-api already exists". + # Recovery: delete that log group before re-running a failed first + # deploy (same class as the RETAIN-orphan recovery in the deploy-role + # runbook / reference_cfn_deploy_role_gotchas). + api_log_group = common.make_function_log_group( + self, "ProcurementApi", "procurement-api" + ) + api_fn = lambda_.Function( + self, + "ProcurementApi", + function_name="procurement-api", + runtime=lambda_.Runtime.PYTHON_3_12, + architecture=lambda_.Architecture.ARM_64, + handler="handler.handler", + code=lambda_.Code.from_asset( + "../lambdas", + exclude=["**/__pycache__/**"], + bundling=cdk.BundlingOptions( + image=lambda_.Runtime.PYTHON_3_12.bundling_image, + command=[ + "bash", + "-c", + # Non-recursive glob ships every api/ sibling (the + # allowlist-omission trap from PR #105/PR #2); the spec, + # docs page, and the vendored Redoc bundle ride along + # because the handler serves them from its own package + # dir. web_ui_auth.py must land FLAT beside handler.py + # for the bare import. + "cp api/*.py /asset-output/ && " + "cp api/openapi.json /asset-output/ && " + "cp api/docs.html /asset-output/ && " + "cp api/redoc.standalone.js /asset-output/ && " + "cp api/fonts.css /asset-output/ && " + "cp shared/web_ui_auth.py /asset-output/ && " + "rm -rf /asset-output/__pycache__", + ], + ), + ), + timeout=Duration.seconds(30), + memory_size=256, + log_group=api_log_group, + environment={ + "WORK_ORDERS_TABLE": work_orders_table.table_name, + "COMMENTS_TABLE": comments_table.table_name, + "PO_TABLE": po_table.table_name, + "VERIFIED_SITES_TABLE": verified_sites_table.table_name, + "WEB_UI_AUTH_TOKEN_SECRET_ARN": web_ui_auth_secret.secret_arn, + }, + ) + + work_orders_table.grant_read_data(api_fn) + comments_table.grant_read_data(api_fn) + po_table.grant_read_data(api_fn) + verified_sites_table.grant_read_data(api_fn) + web_ui_auth_secret.grant_read(api_fn) + api_fn.add_to_role_policy( + iam.PolicyStatement( + actions=["kms:Decrypt", "kms:DescribeKey"], + resources=[dynamodb_cmk.key_arn], + # Scope the grant to the DynamoDB data path only: the role can + # decrypt purchase-orders items via DynamoDB, never call + # kms:Decrypt directly on arbitrary ciphertext under the shared + # org CMK. + conditions={ + "StringEquals": { + "kms:ViaService": f"dynamodb.{self.region}.amazonaws.com" + } + }, + ) + ) + + # Resource policy: once a REST API has one, anything not explicitly + # allowed is denied -- so the docs routes need their own Allow or the + # NONE-auth methods would be black-holed. The docs routes are still + # token-gated inside the Lambda (fail-closed), so this is not an + # unauthenticated data path (INFRA-74 posture). + # + # The SHOC data grant enumerates the exact GET resources rather than + # GET/*: adding a RESOURCE must be as reviewable as adding a PRINCIPAL, + # so a future GET route can't silently inherit cross-account reach + # without a policy diff. (Note: this resource policy binds CROSS-account + # callers only; a same-account principal holding execute-api:Invoke is + # authorized by its own identity policy under AWS union semantics -- it + # is NOT constrained here, including on the planned PATCH/POST methods, + # which is why those also rely on the 501 handler + absent write grant, + # not on this policy, until phase 2.) + shoc_data_resources = [ + f"execute-api:/{STAGE_NAME}/GET/work-orders", + f"execute-api:/{STAGE_NAME}/GET/work-orders/*", + f"execute-api:/{STAGE_NAME}/GET/purchase-orders", + f"execute-api:/{STAGE_NAME}/GET/purchase-orders/*", + f"execute-api:/{STAGE_NAME}/GET/verified-sites", + f"execute-api:/{STAGE_NAME}/GET/verified-sites/*", + ] + api_policy = iam.PolicyDocument( + statements=[ + iam.PolicyStatement( + sid="ShocBackendDevDataRead", + principals=[iam.ArnPrincipal(SHOC_BACKEND_DEV_ROLE_ARN)], + actions=["execute-api:Invoke"], + resources=shoc_data_resources, + ), + # SECURITY INVARIANT: this AnyPrincipal allow is safe only + # while /docs//openapi.json serve static docs (handler + # enforces the shared token, fail-closed). Widening these + # routes to dynamic data, or enabling access logging (which + # would record the docs ?token= shim), requires a security + # re-review + docs-token rotation. + iam.PolicyStatement( + sid="DocsTokenGatedRoutes", + principals=[iam.AnyPrincipal()], + actions=["execute-api:Invoke"], + resources=[ + f"execute-api:/{STAGE_NAME}/GET/docs", + f"execute-api:/{STAGE_NAME}/GET/openapi.json", + ], + ), + ] + ) + + # OPERATIONAL NOTE: API Gateway serves the resource policy from the + # deployed stage snapshot, and CDK's Deployment hash is computed from + # resources/methods, not the RestApi Policy. A later policy-ONLY change + # (e.g. revoking the SHOC role) will UPDATE the RestApi but keep serving + # the old policy until a new Deployment is forced (any method/resource + # change, or a salted deployment). When tightening this policy, force a + # redeploy and verify the effective policy post-deploy. + api = apigateway.RestApi( + self, + "ProcurementRestApi", + rest_api_name="procurement-api", + description=( + "Read API over procurement-ingest work orders + purchase " + "orders; token-gated OpenAPI docs at /docs" + ), + endpoint_types=[apigateway.EndpointType.REGIONAL], + policy=api_policy, + deploy_options=apigateway.StageOptions( + stage_name=STAGE_NAME, + # Bound the blast radius of the unauthenticated /docs routes + # (and the whole API) below the 10k rps account default -- this + # is a low-volume reconciliation/backfill API, not a hot path. + throttling_rate_limit=50, + throttling_burst_limit=100, + ), + # No access/execution logging in v1: avoids the account-level API + # Gateway CloudWatch role prerequisite AND keeps the docs ?token= + # query shim out of any log. Rotate the docs token before ever + # enabling access logging here. + cloud_watch_role=False, + ) + + integration = apigateway.LambdaIntegration(api_fn) + iam_auth = {"authorization_type": apigateway.AuthorizationType.IAM} + + work_orders = api.root.add_resource("work-orders") + work_orders.add_method("GET", integration, **iam_auth) + wo_by_id = work_orders.add_resource("{workOrderId}") + wo_by_id.add_method("GET", integration, **iam_auth) + # Phase-2 planned write endpoints: deployed but the handler answers 501 + # and the role holds no DynamoDB write grant. The resource policy denies + # these to the cross-account SHOC role (GET-only enumeration above); a + # same-account caller is NOT blocked by the resource policy, so the 501 + # handler + absent write grant are the real gate until phase 2 lands the + # deliberate policy + handler + write-grant change with its own review. + wo_by_id.add_method("PATCH", integration, **iam_auth) + wo_comments = wo_by_id.add_resource("comments") + wo_comments.add_method("GET", integration, **iam_auth) + wo_comments.add_method("POST", integration, **iam_auth) + + purchase_orders = api.root.add_resource("purchase-orders") + purchase_orders.add_method("GET", integration, **iam_auth) + purchase_orders.add_resource("{poNumber}").add_method( + "GET", integration, **iam_auth + ) + + verified_sites = api.root.add_resource("verified-sites") + verified_sites.add_method("GET", integration, **iam_auth) + verified_sites.add_resource("{siteCode}").add_method( + "GET", integration, **iam_auth + ) + + api.root.add_resource("docs").add_method( + "GET", + integration, + authorization_type=apigateway.AuthorizationType.NONE, + ) + api.root.add_resource("openapi.json").add_method( + "GET", + integration, + authorization_type=apigateway.AuthorizationType.NONE, + ) + + # --- Alarms (ALARM-only -> site-alerts, NOT_BREACHING) --- + # common.add_standard_lambda_alarms is NOT used here: its duration + # threshold is a fixed 45000 ms (75% of the processors' 60 s timeout), + # which this function's 30 s timeout can never reach. Same idiom, + # right-sized thresholds. + api_fn.metric_errors(period=Duration.minutes(5), statistic="Sum").create_alarm( + self, + "ProcurementApiErrorsAlarm", + alarm_name="procurement-api-errors", + alarm_description=( + "procurement-api Lambda raised (bundle/init failures; the " + "handler catches request errors, so any signal here is " + "structural)" + ), + threshold=0, + evaluation_periods=1, + comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD, + treat_missing_data=cloudwatch.TreatMissingData.NOT_BREACHING, + ).add_alarm_action(cw_actions.SnsAction(alarm_topic)) + + api_fn.metric_throttles( + period=Duration.minutes(5), statistic="Sum" + ).create_alarm( + self, + "ProcurementApiThrottlesAlarm", + alarm_name="procurement-api-throttles", + alarm_description="procurement-api Lambda throttled", + threshold=0, + evaluation_periods=1, + comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD, + treat_missing_data=cloudwatch.TreatMissingData.NOT_BREACHING, + ).add_alarm_action(cw_actions.SnsAction(alarm_topic)) + + api_fn.metric_duration( + period=Duration.minutes(5), statistic="p99" + ).create_alarm( + self, + "ProcurementApiDurationAlarm", + alarm_name="procurement-api-duration", + alarm_description=( + "procurement-api p99 duration >= 22.5s (75% of the 30s " + "timeout; scans degrading toward timeout)" + ), + threshold=22500, + evaluation_periods=3, + datapoints_to_alarm=2, + comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD, + treat_missing_data=cloudwatch.TreatMissingData.NOT_BREACHING, + ).add_alarm_action(cw_actions.SnsAction(alarm_topic)) + + # Gateway-side 5xx: catches what the Lambda's own Errors metric can't + # (the handler returns clean 500s; integration faults surface here). + # No 4XX alarm -- 401/403/404 are expected traffic. + cloudwatch.Metric( + namespace="AWS/ApiGateway", + metric_name="5XXError", + dimensions_map={"ApiName": "procurement-api", "Stage": STAGE_NAME}, + period=Duration.minutes(5), + statistic="Sum", + ).create_alarm( + self, + "ProcurementApi5xxAlarm", + alarm_name="procurement-api-5xx", + alarm_description="procurement-api gateway 5XX responses", + threshold=0, + evaluation_periods=1, + comparison_operator=cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD, + treat_missing_data=cloudwatch.TreatMissingData.NOT_BREACHING, + ).add_alarm_action(cw_actions.SnsAction(alarm_topic)) + + cdk.CfnOutput( + self, + "ApiEndpointUrl", + value=api.url, + description="procurement-api invoke URL (stage prod)", + ) + cdk.CfnOutput( + self, + "ProcurementApiFunctionArn", + value=api_fn.function_arn, + description="ARN of the procurement-api Lambda", + ) diff --git a/infra/deploy-role/README.md b/infra/deploy-role/README.md index 5dbfec5..94ea7a1 100644 --- a/infra/deploy-role/README.md +++ b/infra/deploy-role/README.md @@ -10,19 +10,20 @@ stays untouched until decommission as the emergency mgmt deploy path. | File | Purpose | |---|---| | `trust-policy.json` | OIDC trust: `repo:Sea-Haven-Industries/procurement-ingest:ref:refs/heads/main` only | -| `permissions-policy.json` | `sts:AssumeRole` on the four `cdk-hnb659fds-*` bootstrap roles, `cloudformation:DescribeStacks` scoped to this repo's stacks + `CDKToolkit` (cd-cdk health check), and `lambda:InvokeFunction` on exactly the two email-processor function ARNs (post-deploy smoke gate) | +| `permissions-policy.json` | `sts:AssumeRole` on the four `cdk-hnb659fds-*` bootstrap roles, `cloudformation:DescribeStacks` scoped to this repo's stacks + `CDKToolkit` (cd-cdk health check), and `lambda:InvokeFunction` on exactly the three smoke-gated function ARNs (post-deploy smoke gate) | | `create-deploy-role.sh` | Idempotent create-or-update from the two JSON files, profile `seahaven-prod` | -> **Maintenance note:** `DescribeStacks` is scoped to `stack/po-ingest/*`, `stack/WorkorderIngestStack/*`, and `stack/CDKToolkit/*`. If a third stack is ever added to this CDK app, add its ARN pattern here and re-run the review-then-apply flow — otherwise the cd-cdk health check on the new stack will `AccessDenied`. +> **Maintenance note:** `DescribeStacks` is scoped to `stack/po-ingest/*`, `stack/WorkorderIngestStack/*`, `stack/procurement-api/*` (added with the procurement-api stack), and `stack/CDKToolkit/*`. If another stack is ever added to this CDK app, add its ARN pattern here and re-run the review-then-apply flow — otherwise the cd-cdk health check on the new stack will `AccessDenied`. ## Why the SmokeInvokeLambda statement exists `deploy.yaml` runs `scripts/post-deploy-smoke.sh` under the deploy role's own session, not the assumed `cdk-*` roles. Without `lambda:InvokeFunction` on the -two function ARNs the smoke gate hits AccessDenied and every deploy fails -closed. The mgmt-era grant was applied out-of-band and undocumented; keeping -it in these reviewed artifacts closes that gap. Scope it to exactly the two -ARNs, never `Resource: "*"`. +smoke-gated function ARNs (the two email processors + `procurement-api`) the +smoke gate hits AccessDenied and every deploy fails closed. The mgmt-era grant +was applied out-of-band and undocumented; keeping it in these reviewed +artifacts closes that gap. Scope it to exactly the named ARNs, never +`Resource: "*"`. ## Change process diff --git a/infra/deploy-role/permissions-policy.json b/infra/deploy-role/permissions-policy.json index e29ba7e..fc7261b 100644 --- a/infra/deploy-role/permissions-policy.json +++ b/infra/deploy-role/permissions-policy.json @@ -19,6 +19,7 @@ "Resource": [ "arn:aws:cloudformation:us-east-1:011934824531:stack/po-ingest/*", "arn:aws:cloudformation:us-east-1:011934824531:stack/WorkorderIngestStack/*", + "arn:aws:cloudformation:us-east-1:011934824531:stack/procurement-api/*", "arn:aws:cloudformation:us-east-1:011934824531:stack/CDKToolkit/*" ], "Condition": { @@ -33,7 +34,8 @@ "Action": "lambda:InvokeFunction", "Resource": [ "arn:aws:lambda:us-east-1:011934824531:function:po-email-processor", - "arn:aws:lambda:us-east-1:011934824531:function:workorder-email-processor" + "arn:aws:lambda:us-east-1:011934824531:function:workorder-email-processor", + "arn:aws:lambda:us-east-1:011934824531:function:procurement-api" ] } ] diff --git a/lambdas/api/docs.html b/lambdas/api/docs.html new file mode 100644 index 0000000..7fe60a1 --- /dev/null +++ b/lambdas/api/docs.html @@ -0,0 +1,162 @@ + + + + + +Procurement Ingest API + + + + + + +
+ Sea Haven Industries + + Procurement Ingest API +
+
+ + + + diff --git a/lambdas/api/fonts.css b/lambdas/api/fonts.css new file mode 100644 index 0000000..7d95184 --- /dev/null +++ b/lambdas/api/fonts.css @@ -0,0 +1,37 @@ +/* Sea Haven design-system fonts (SHOC token set), vendored offline as data + * URIs so /docs stays a single self-contained response (no Google Fonts). + * Source: @fontsource/dm-sans, @fontsource/montserrat, + * @fontsource/jetbrains-mono 5.3.0 (OFL), latin subset, normal style. + * Generated by scratchpad gen_fonts_css.py; regenerate on font bumps. */ + +@font-face { + font-family: "DM Sans"; + font-style: normal; + font-weight: 400; + font-display: swap; + src: url(data:font/woff2;base64,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) format("woff2"); +} + +@font-face { + font-family: "DM Sans"; + font-style: normal; + font-weight: 600; + font-display: swap; + src: url(data:font/woff2;base64,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) format("woff2"); +} + +@font-face { + font-family: "Montserrat"; + font-style: normal; + font-weight: 600; + font-display: swap; + src: url(data:font/woff2;base64,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) format("woff2"); +} + +@font-face { + font-family: "JetBrains Mono"; + font-style: normal; + font-weight: 400; + font-display: swap; + src: url(data:font/woff2;base64,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) format("woff2"); +} diff --git a/lambdas/api/handler.py b/lambdas/api/handler.py new file mode 100644 index 0000000..6824847 --- /dev/null +++ b/lambdas/api/handler.py @@ -0,0 +1,235 @@ +"""Procurement API Lambda (API Gateway REST proxy integration). + +Auth is split by route class and enforced at two layers: +- Data routes: AWS_IAM at the gateway (SigV4; cross-account callers allowed by + the API resource policy). The handler does NOT re-check a token there -- + authorization is API Gateway's job on those routes. +- Docs routes (/docs, /openapi.json): reachable at the gateway (auth NONE + + resource-policy carve-out) but the handler fails closed on the shared + header token via web_ui_auth (same secret + constant-time compare as the + web UIs), so they are never an unauthenticated data path (INFRA-74). +""" + +import logging +from pathlib import Path + +import po_repo +import wo_repo +from botocore.exceptions import ClientError +from pagination import BadCursor, clamp_limit +from router import DATA_ROUTES, DOCS_ROUTES, PLANNED_ROUTES +from serialization import error_response, json_response +from web_ui_auth import is_authenticated + +logger = logging.getLogger() +logger.setLevel(logging.INFO) + +_MODULE_DIR = Path(__file__).resolve().parent +_SPEC_PATH = _MODULE_DIR / "openapi.json" +_DOCS_PATH = _MODULE_DIR / "docs.html" +_REDOC_JS_PATH = _MODULE_DIR / "redoc.standalone.js" +_FONTS_CSS_PATH = _MODULE_DIR / "fonts.css" +# The docs page template carries these placeholders, filled server-side so +# /docs is a single token-gated request (a browser can't attach the auth +# header to a follow-up asset fetch) with the vendored Redoc bundle, the +# design-system fonts, and the spec inlined, no CDN. +_SPEC_PLACEHOLDER = "__OPENAPI_SPEC_JSON__" +_JS_PLACEHOLDER = "__REDOC_JS__" +_FONTS_PLACEHOLDER = "__FONTS_CSS__" + +_spec_cache = None +_docs_shell_cache = None +# The server URL committed in openapi.json; swapped for the live invoke URL +# (derived from the request) when the spec is served, so the docs page shows a +# correct, current endpoint even if the RestApi is recreated. +_COMMITTED_SERVER_URL = "https://mvul1efda2.execute-api.us-east-1.amazonaws.com/prod" + +_REPO_FUNCS = { + "list_work_orders": wo_repo.list_work_orders, + "get_work_order": wo_repo.get_work_order, + "list_comments": wo_repo.list_comments, + "list_purchase_orders": po_repo.list_purchase_orders, + "get_purchase_order": po_repo.get_purchase_order, + "list_verified_sites": po_repo.list_verified_sites, + "get_verified_site": po_repo.get_verified_site, +} + +_PATH_PARAM_BY_RESOURCE = { + "/work-orders/{workOrderId}": "workOrderId", + "/work-orders/{workOrderId}/comments": "workOrderId", + "/purchase-orders/{poNumber}": "poNumber", + "/verified-sites/{siteCode}": "siteCode", +} + + +# Headers on the docs responses: the token rides in the ?token= query shim, +# so keep the token-keyed URL and page out of shared/browser caches and out of +# any Referer sent to a followed link. +_DOCS_SECURITY_HEADERS = { + "Cache-Control": "no-store", + "Referrer-Policy": "no-referrer", +} + + +def _load_spec() -> str: + """The committed spec text (cached).""" + global _spec_cache + if _spec_cache is None: + _spec_cache = _SPEC_PATH.read_text(encoding="utf-8") + return _spec_cache + + +def _base_url(event: dict) -> str | None: + rc = event.get("requestContext") or {} + domain, stage = rc.get("domainName"), rc.get("stage") + return f"https://{domain}/{stage}" if domain and stage else None + + +def _spec_for_request(event: dict) -> str: + """Committed spec with servers[0].url set to the live invoke URL when the + request context provides it (falls back to the committed literal).""" + raw = _load_spec() + base = _base_url(event) + return raw.replace(_COMMITTED_SERVER_URL, base) if base else raw + + +def _docs_shell() -> str: + """The Redoc page with the vendored bundle inlined; the SPEC placeholder + is left intact so the per-request server-injected spec splices in cheaply + (the heavy ~1.1MB bundle is assembled once and cached). + + Each blob is spliced into a "},this.getStyleTags=function(){return e.sealed?Ki(2):e._emitSheetCSS()},this.getStyleElement=function(){var t;if(e.sealed)return Ki(2);var n=((t={})[Wi]="",t["data-styled-version"]="5.3.11",t.dangerouslySetInnerHTML={__html:e.instance.toString()},t),i=ao();return i&&(n.nonce=i),[r.createElement("style",Di({},n,{key:"sc-0-0"}))]},this.seal=function(){e.sealed=!0},this.instance=new mo({isServer:!0}),this.sealed=!1}.prototype).collectStyles=function(e){return this.sealed?Ki(2):r.createElement(No,{sheet:this.instance},e)},os.interleaveWithNodeStream=function(e){return Ki(3)};var cs=is;const{Ay:us,AH:ps,DU:ds,i7:fs,NP:hs}=e,ms={lessThan(e,t,r){return(...n)=>ps` + @media ${t?"print, ":""} screen and (max-width: ${t=>t.theme.breakpoints[e]}) ${r||""} { + ${ps(...n)}; + } + `},greaterThan(e){return(...t)=>ps` + @media (min-width: ${t=>t.theme.breakpoints[e]}) { + ${ps(...t)}; + } + `},between(e,t){return(...r)=>ps` + @media (min-width: ${t=>t.theme.breakpoints[e]}) and (max-width: ${e=>e.theme.breakpoints[t]}) { + ${ps(...r)}; + } + `}};var gs=us;function ys(e){return t=>{if(t.theme.extensionsHook)return t.theme.extensionsHook(e,t)}}const bs=gs.div` + padding: 20px; + color: red; +`;class vs extends r.Component{constructor(e){super(e),this.state={error:void 0}}componentDidCatch(e){return this.setState({error:e}),!1}render(){return this.state.error?r.createElement(bs,null,r.createElement("h1",null,"Something went wrong..."),r.createElement("small",null," ",this.state.error.message," "),r.createElement("p",null,r.createElement("details",null,r.createElement("summary",null,"Stack trace"),r.createElement("pre",null,this.state.error.stack))),r.createElement("small",null," ReDoc Version: ","2.5.3")," ",r.createElement("br",null),r.createElement("small",null," Commit: ","1b2591e")):r.createElement(r.Fragment,null,r.Children.only(this.props.children))}}const xs=fs` + 0% { + transform: rotate(0deg); } + 100% { + transform: rotate(360deg); + } +`,ws=gs(e=>r.createElement("svg",{className:e.className,version:"1.1",width:"512",height:"512",viewBox:"0 0 512 512"},r.createElement("path",{d:"M275.682 147.999c0 10.864-8.837 19.661-19.682 19.661v0c-10.875 0-19.681-8.796-19.681-19.661v-96.635c0-10.885 8.806-19.661 19.681-19.661v0c10.844 0 19.682 8.776 19.682 19.661v96.635z"}),r.createElement("path",{d:"M275.682 460.615c0 10.865-8.837 19.682-19.682 19.682v0c-10.875 0-19.681-8.817-19.681-19.682v-96.604c0-10.885 8.806-19.681 19.681-19.681v0c10.844 0 19.682 8.796 19.682 19.682v96.604z"}),r.createElement("path",{d:"M147.978 236.339c10.885 0 19.681 8.755 19.681 19.641v0c0 10.885-8.796 19.702-19.681 19.702h-96.624c-10.864 0-19.661-8.817-19.661-19.702v0c0-10.885 8.796-19.641 19.661-19.641h96.624z"}),r.createElement("path",{d:"M460.615 236.339c10.865 0 19.682 8.755 19.682 19.641v0c0 10.885-8.817 19.702-19.682 19.702h-96.584c-10.885 0-19.722-8.817-19.722-19.702v0c0-10.885 8.837-19.641 19.722-19.641h96.584z"}),r.createElement("path",{d:"M193.546 165.703c7.69 7.66 7.68 20.142 0 27.822v0c-7.701 7.701-20.162 7.701-27.853 0.020l-68.311-68.322c-7.68-7.701-7.68-20.142 0-27.863v0c7.68-7.68 20.121-7.68 27.822 0l68.342 68.342z"}),r.createElement("path",{d:"M414.597 386.775c7.7 7.68 7.7 20.163 0.021 27.863v0c-7.7 7.659-20.142 7.659-27.843-0.062l-68.311-68.26c-7.68-7.7-7.68-20.204 0-27.863v0c7.68-7.7 20.163-7.7 27.842 0l68.291 68.322z"}),r.createElement("path",{d:"M165.694 318.464c7.69-7.7 20.153-7.7 27.853 0v0c7.68 7.659 7.69 20.163 0 27.863l-68.342 68.322c-7.67 7.659-20.142 7.659-27.822-0.062v0c-7.68-7.68-7.68-20.122 0-27.801l68.311-68.322z"}),r.createElement("path",{d:"M386.775 97.362c7.7-7.68 20.142-7.68 27.822 0v0c7.7 7.68 7.7 20.183 0.021 27.863l-68.322 68.311c-7.68 7.68-20.163 7.68-27.843-0.020v0c-7.68-7.68-7.68-20.162 0-27.822l68.322-68.332z"})))` + animation: 2s ${xs} linear infinite; + width: 50px; + height: 50px; + content: ''; + display: inline-block; + margin-left: -25px; + + path { + fill: ${e=>e.color}; + } +`,ks=gs.div` + font-family: helvetica, sans; + width: 100%; + text-align: center; + font-size: 25px; + margin: 30px 0 20px 0; + color: ${e=>e.color}; +`;class Ss extends r.PureComponent{render(){return r.createElement("div",{style:{textAlign:"center"}},r.createElement(ks,{color:this.props.color},"Loading ..."),r.createElement(ws,{color:this.props.color}))}}var Es=n(5556);const Os=r.createContext(new _i({})),_s=Os.Provider,Ps=Os.Consumer;var $s=n(854),As=n(8921),Cs=n(65);var js=n(5156),Ts=n(228),Ns=n(1095),Is=n.n(Ns);const Rs=Ns.parse;class Ls{static baseName(e,t=1){const r=Ls.parse(e);return r[r.length-t]}static dirName(e,t=1){const r=Ls.parse(e);return Ns.compile(r.slice(0,r.length-t))}static relative(e,t){const r=Ls.parse(e);return Ls.parse(t).slice(r.length)}static parse(e){let t=e;return"#"===t.charAt(0)&&(t=t.substring(1)),Rs(t)}static join(e,t){const r=Ls.parse(e).concat(t);return Ns.compile(r)}static get(e,t){return Ns.get(e,t)}static compile(e){return Ns.compile(e)}static escape(e){return Ns.escape(e)}}Ns.parse=Ls.parse,Object.assign(Ls,Ns);var Ds=n(7975),Ms=n(8769),zs=Object.defineProperty,Fs=Object.defineProperties,Bs=Object.getOwnPropertyDescriptors,Us=Object.getOwnPropertySymbols,qs=Object.prototype.hasOwnProperty,Vs=Object.prototype.propertyIsEnumerable,Ws=(e,t,r)=>t in e?zs(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Hs=(e,t)=>{for(var r in t||(t={}))qs.call(t,r)&&Ws(e,r,t[r]);if(Us)for(var r of Us(t))Vs.call(t,r)&&Ws(e,r,t[r]);return e},Gs=(e,t)=>Fs(e,Bs(t));function Ys(e){return"string"==typeof e&&/\dxx/i.test(e)}function Ks(e,t=!1){if("default"===e)return t?"error":"success";let r="string"==typeof e?parseInt(e,10):e;if(Ys(e)&&(r*=100),r<100||r>599)throw new Error("invalid HTTP code");let n="success";return r>=300&&r<400?n="redirect":r>=400?n="error":r<200&&(n="info"),n}const Qs={get:!0,post:!0,put:!0,head:!0,patch:!0,delete:!0,options:!0,$ref:!0};function Xs(e){return e in Qs}const Js={multipleOf:"number",maximum:"number",exclusiveMaximum:"number",minimum:"number",exclusiveMinimum:"number",maxLength:"string",minLength:"string",pattern:"string",contentEncoding:"string",contentMediaType:"string",items:"array",maxItems:"array",minItems:"array",uniqueItems:"array",maxProperties:"object",minProperties:"object",required:"object",additionalProperties:"object",unevaluatedProperties:"object",properties:"object",patternProperties:"object"};function Zs(e,t=e.type){if(e["x-circular-ref"])return!0;if(void 0!==e.oneOf||void 0!==e.anyOf)return!1;if(e.if&&e.then||e.if&&e.else)return!1;let r=!0;const n=pi(t);return("object"===t||n&&(null==t?void 0:t.includes("object")))&&(r=void 0!==e.properties?0===Object.keys(e.properties).length:void 0===e.additionalProperties&&void 0===e.unevaluatedProperties&&void 0===e.patternProperties),!pi(e.items)&&!pi(e.prefixItems)&&(void 0!==e.items&&!di(e.items)&&("array"===t||n&&(null==t?void 0:t.includes("array")))&&(r=Zs(e.items,e.items.type)),r)}function ea(e){return-1!==e.search(/json/i)}function ta(e,t,r){return pi(e)?e.map(e=>e.toString()).join(r):"object"==typeof e?Object.keys(e).map(t=>`${t}${r}${e[t]}`).join(r):t+"="+e.toString()}function ra(e,t){return pi(e)?(console.warn("deepObject style cannot be used with array value:"+e.toString()),""):"object"==typeof e?Object.keys(e).map(r=>`${t}[${r}]=${e[r]}`).join("&"):(console.warn("deepObject style cannot be used with non-object value:"+e.toString()),"")}function na(e,t,r){const n="__redoc_param_name__",i=t?"*":"";return Ms.parse(`{?${n}${i}}`).expand({[n]:r}).substring(1).replace(/__redoc_param_name__/g,e)}function ia(e,t){return ea(t)?JSON.stringify(e):(console.warn(`Parameter serialization as ${t} is not supported`),"")}function oa(e,t){return e.in?decodeURIComponent(function(e,t){const{name:r,style:n,explode:i=!1,serializationMime:o}=e;if(o)switch(e.in){case"path":case"header":return ia(t,o);case"cookie":case"query":return`${r}=${ia(t,o)}`;default:return console.warn("Unexpected parameter location: "+e.in),""}if(!n)return console.warn(`Missing style attribute or content for parameter ${r}`),"";switch(e.in){case"path":return function(e,t,r,n){const i=r?"*":"";let o="";"label"===t?o=".":"matrix"===t&&(o=";");const s="__redoc_param_name__";return Ms.parse(`{${o}${s}${i}}`).expand({[s]:n}).replace(/__redoc_param_name__/g,e)}(r,n,i,t);case"query":return function(e,t,r,n){switch(t){case"form":return na(e,r,n);case"spaceDelimited":return pi(n)?r?na(e,r,n):`${e}=${n.join("%20")}`:(console.warn("The style spaceDelimited is only applicable to arrays"),"");case"pipeDelimited":return pi(n)?r?na(e,r,n):`${e}=${n.join("|")}`:(console.warn("The style pipeDelimited is only applicable to arrays"),"");case"deepObject":return!r||pi(n)||"object"!=typeof n?(console.warn("The style deepObject is only applicable for objects with explode=true"),""):ra(n,e);default:return console.warn("Unexpected style for query: "+t),""}}(r,n,i,t);case"header":return function(e,t,r){if("simple"===e){const e=t?"*":"",n="__redoc_param_name__",i=Ms.parse(`{${n}${e}}`);return decodeURIComponent(i.expand({[n]:r}))}return console.warn("Unexpected style for header: "+e),""}(n,i,t);case"cookie":return function(e,t,r,n){return"form"===t?na(e,r,n):(console.warn("Unexpected style for cookie: "+t),"")}(r,n,i,t);default:return console.warn("Unexpected parameter location: "+e.in),""}}(e,t)):"object"==typeof t?t:String(t)}const sa=/^#\/components\/(schemas|pathItems)\/([^/]+)$/;function aa(e){return sa.test(e||"")}function la(e){var t;const[r]=(null==(t=null==e?void 0:e.match(sa))?void 0:t.reverse())||[];return r}function ca(e,t,r){let n;return void 0!==t&&void 0!==r?n=t===r?`= ${t} ${e}`:`[ ${t} .. ${r} ] ${e}`:void 0!==r?n=`<= ${r} ${e}`:void 0!==t&&(n=1===t?"non-empty":`>= ${t} ${e}`),n}function ua(e){const t=[],r=ca("characters",e.minLength,e.maxLength);void 0!==r&&t.push(r);const n=ca("items",e.minItems,e.maxItems);void 0!==n&&t.push(n);const i=ca("properties",e.minProperties,e.maxProperties);void 0!==i&&t.push(i);const o=function(e){if(void 0===e)return;const t=e.toString(10);return/^0\.0*1$/.test(t)?`decimal places <= ${t.split(".")[1].length}`:`multiple of ${t}`}(e.multipleOf);void 0!==o&&t.push(o);const s=function(e){var t,r;const n="number"==typeof e.exclusiveMinimum?Math.min(e.exclusiveMinimum,null!=(t=e.minimum)?t:1/0):e.minimum,i="number"==typeof e.exclusiveMaximum?Math.max(e.exclusiveMaximum,null!=(r=e.maximum)?r:-1/0):e.maximum,o="number"==typeof e.exclusiveMinimum||e.exclusiveMinimum,s="number"==typeof e.exclusiveMaximum||e.exclusiveMaximum;return void 0!==n&&void 0!==i?`${o?"( ":"[ "}${n} .. ${i}${s?" )":" ]"}`:void 0!==i?`${s?"< ":"<= "}${i}`:void 0!==n?`${o?"> ":">= "}${n}`:void 0}(e);return void 0!==s&&t.push(s),e.uniqueItems&&t.push("unique"),t}function pa(e,t=[]){const r=[],n=[],i=[];return e.forEach(e=>{e.required?t.includes(e.name)?n.push(e):i.push(e):r.push(e)}),n.sort((e,r)=>t.indexOf(e.name)-t.indexOf(r.name)),[...n,...i,...r]}function da(e,t){return[...e].sort((e,r)=>e[t].localeCompare(r[t]))}function fa(e,t){const r=void 0===e?function(e){try{const t=ci(e);return t.search="",t.hash="",t.toString()}catch(t){return e}}((()=>{if(!Qn)return"";const e=window.location.href;return e.endsWith(".html")?(0,Ds.dirname)(e):e})()):(0,Ds.dirname)(e);return 0===t.length&&(t=[{url:"/"}]),t.map(e=>{return Gs(Hs({},e),{url:(t=e.url,function(e,t){let r;if(t.startsWith("//"))try{r=`${new URL(e).protocol||"https:"}${t}`}catch(e){r=`https:${t}`}else if(function(e){return/(?:^[a-z][a-z0-9+.-]*:|\/\/)/i.test(e)}(t))r=t;else if(t.startsWith("/"))try{const n=new URL(e);n.pathname=t,r=n.href}catch(e){r=t}else r=ni(e)+"/"+t;return ni(r)}(r,t)),description:e.description||""});var t})}const ha="SecurityDefinitions",ma="security-definitions",ga="SchemaDefinition";let ya="section/Authentication/";const ba=e=>({delete:"del",options:"opts"}[e]||e);function va(e,t){return Object.keys(e).filter(e=>!0===t?e.startsWith("x-")&&!function(e){return e in{"x-circular-ref":!0,"x-parentRefs":!0,"x-refsStack":!0,"x-code-samples":!0,"x-codeSamples":!0,"x-displayName":!0,"x-examples":!0,"x-enumDescriptions":!0,"x-logo":!0,"x-nullable":!0,"x-servers":!0,"x-tagGroups":!0,"x-traitTag":!0,"x-badges":!0,"x-additionalPropertiesName":!0,"x-explicitMappingOnly":!0}}(e):e.startsWith("x-")&&t.indexOf(e)>-1).reduce((t,r)=>(t[r]=e[r],t),{})}var xa=n(8848);n(7022),n(271),n(5624),n(4511),n(2415),n(5651),n(6378),n(4784),n(6976),n(64),n(9700),n(4312),n(596),n(2821),n(3554),n(2342),n(4113),n(1648),n(4252),n(6966),n(4793),n(83),n(2630);const wa="clike";function ka(e,t=wa){t=t.toLowerCase();let r=xa.languages[t];return r||(r=xa.languages[function(e){return{json:"js","c++":"cpp","c#":"csharp","objective-c":"objectivec",shell:"bash",viml:"vim"}[e]||wa}(t)]),xa.highlight(e.toString(),r,t)}xa.languages.insertBefore("javascript","string",{"property string":{pattern:/([{,]\s*)"(?:\\.|[^\\"\r\n])*"(?=\s*:)/i,lookbehind:!0}},void 0),xa.languages.insertBefore("javascript","punctuation",{property:{pattern:/([{,]\s*)[a-z]\w*(?=\s*:)/i,lookbehind:!0}},void 0);var Sa=Object.defineProperty,Ea=Object.defineProperties,Oa=Object.getOwnPropertyDescriptors,_a=Object.getOwnPropertySymbols,Pa=Object.prototype.hasOwnProperty,$a=Object.prototype.propertyIsEnumerable,Aa=(e,t,r)=>t in e?Sa(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Ca=(e,t)=>{for(var r in t||(t={}))Pa.call(t,r)&&Aa(e,r,t[r]);if(_a)for(var r of _a(t))$a.call(t,r)&&Aa(e,r,t[r]);return e},ja=(e,t)=>Ea(e,Oa(t));const Ta={};function Na(e,t,r){if("function"==typeof r.value)return function(e,t,r){if(!r.value||r.value.length>0)throw new Error("@memoize decorator can only be applied to methods of zero arguments");const n=`_memoized_${t}`,i=r.value;return e[n]=Ta,ja(Ca({},r),{value(){return this[n]===Ta&&(this[n]=i.call(this)),this[n]}})}(e,t,r);if("function"==typeof r.get)return function(e,t,r){const n=`_memoized_${t}`,i=r.get;return e[n]=Ta,ja(Ca({},r),{get(){return this[n]===Ta&&(this[n]=i.call(this)),this[n]}})}(e,t,r);throw new Error("@memoize decorator can be applied to methods or getters, got "+String(r.value)+" instead")}function Ia(e){let t=1;return"-"===e[0]&&(t=-1,e=e.substr(1)),(r,n)=>-1==t?n[e].localeCompare(r[e]):r[e].localeCompare(n[e])}var Ra=Object.defineProperty,La=Object.getOwnPropertyDescriptor;const Da="hashchange";class Ma{constructor(){this.emit=()=>{this._emiter.emit(Da,this.currentId)},this._emiter=new Ts,this.bind()}get currentId(){return Qn?decodeURIComponent(window.location.hash.substring(1)):""}linkForId(e){return e?"#"+e:""}subscribe(e){const t=this._emiter.addListener(Da,e);return()=>t.removeListener(Da,e)}bind(){Qn&&window.addEventListener("hashchange",this.emit,!1)}dispose(){Qn&&window.removeEventListener("hashchange",this.emit)}replace(e,t=!1){Qn&&null!=e&&e!==this.currentId&&(t?window.history.replaceState(null,"",window.location.href.split("#")[0]+this.linkForId(e)):(window.history.pushState(null,"",window.location.href.split("#")[0]+this.linkForId(e)),this.emit()))}}((e,t,r)=>{for(var n,i=La(t,r),o=e.length-1;o>=0;o--)(n=e[o])&&(i=n(t,r,i)||i);i&&Ra(t,r,i)})([js.bind,js.debounce],Ma.prototype,"replace");const za=new Ma;var Fa=n(689);class Ba{constructor(){this.map=new Map,this.prevTerm=""}add(e){this.map.set(e,new Fa(e))}delete(e){this.map.delete(e)}addOnly(e){this.map.forEach((t,r)=>{-1===e.indexOf(r)&&(t.unmark(),this.map.delete(r))});for(const t of e)this.map.has(t)||this.map.set(t,new Fa(t))}clearAll(){this.unmark(),this.map.clear()}mark(e){(e||this.prevTerm)&&(this.map.forEach(t=>{t.unmark(),t.mark(e||this.prevTerm)}),this.prevTerm=e||this.prevTerm)}unmark(){this.map.forEach(e=>e.unmark()),this.prevTerm=""}}let Ua={async:!1,baseUrl:null,breaks:!1,extensions:null,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,hooks:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:null,sanitize:!1,sanitizer:null,silent:!1,smartypants:!1,tokenizer:null,walkTokens:null,xhtml:!1};const qa=/[&<>"']/,Va=new RegExp(qa.source,"g"),Wa=/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,Ha=new RegExp(Wa.source,"g"),Ga={"&":"&","<":"<",">":">",'"':""","'":"'"},Ya=e=>Ga[e];function Ka(e,t){if(t){if(qa.test(e))return e.replace(Va,Ya)}else if(Wa.test(e))return e.replace(Ha,Ya);return e}const Qa=/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi;function Xa(e){return e.replace(Qa,(e,t)=>"colon"===(t=t.toLowerCase())?":":"#"===t.charAt(0)?"x"===t.charAt(1)?String.fromCharCode(parseInt(t.substring(2),16)):String.fromCharCode(+t.substring(1)):"")}const Ja=/(^|[^\[])\^/g;function Za(e,t){e="string"==typeof e?e:e.source,t=t||"";const r={replace:(t,n)=>(n=(n=n.source||n).replace(Ja,"$1"),e=e.replace(t,n),r),getRegex:()=>new RegExp(e,t)};return r}const el=/[^\w:]/g,tl=/^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;function rl(e,t,r){if(e){let e;try{e=decodeURIComponent(Xa(r)).replace(el,"").toLowerCase()}catch(e){return null}if(0===e.indexOf("javascript:")||0===e.indexOf("vbscript:")||0===e.indexOf("data:"))return null}t&&!tl.test(r)&&(r=function(e,t){nl[" "+e]||(il.test(e)?nl[" "+e]=e+"/":nl[" "+e]=cl(e,"/",!0));const r=-1===(e=nl[" "+e]).indexOf(":");return"//"===t.substring(0,2)?r?t:e.replace(ol,"$1")+t:"/"===t.charAt(0)?r?t:e.replace(sl,"$1")+t:e+t}(t,r));try{r=encodeURI(r).replace(/%25/g,"%")}catch(e){return null}return r}const nl={},il=/^[^:]+:\/*[^/]*$/,ol=/^([^:]+:)[\s\S]*$/,sl=/^([^:]+:\/*[^/]*)[\s\S]*$/,al={exec:function(){}};function ll(e,t){const r=e.replace(/\|/g,(e,t,r)=>{let n=!1,i=t;for(;--i>=0&&"\\"===r[i];)n=!n;return n?"|":" |"}).split(/ \|/);let n=0;if(r[0].trim()||r.shift(),r.length>0&&!r[r.length-1].trim()&&r.pop(),r.length>t)r.splice(t);else for(;r.length1;)1&t&&(r+=e),t>>=1,e+=e;return r+e}function pl(e,t,r,n){const i=t.href,o=t.title?Ka(t.title):null,s=e[1].replace(/\\([\[\]])/g,"$1");if("!"!==e[0].charAt(0)){n.state.inLink=!0;const e={type:"link",raw:r,href:i,title:o,text:s,tokens:n.inlineTokens(s)};return n.state.inLink=!1,e}return{type:"image",raw:r,href:i,title:o,text:Ka(s)}}class dl{constructor(e){this.options=e||Ua}space(e){const t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:"space",raw:t[0]}}code(e){const t=this.rules.block.code.exec(e);if(t){const e=t[0].replace(/^ {1,4}/gm,"");return{type:"code",raw:t[0],codeBlockStyle:"indented",text:this.options.pedantic?e:cl(e,"\n")}}}fences(e){const t=this.rules.block.fences.exec(e);if(t){const e=t[0],r=function(e,t){const r=e.match(/^(\s+)(?:```)/);if(null===r)return t;const n=r[1];return t.split("\n").map(e=>{const t=e.match(/^\s+/);if(null===t)return e;const[r]=t;return r.length>=n.length?e.slice(n.length):e}).join("\n")}(e,t[3]||"");return{type:"code",raw:e,lang:t[2]?t[2].trim().replace(this.rules.inline._escapes,"$1"):t[2],text:r}}}heading(e){const t=this.rules.block.heading.exec(e);if(t){let e=t[2].trim();if(/#$/.test(e)){const t=cl(e,"#");this.options.pedantic?e=t.trim():t&&!/ $/.test(t)||(e=t.trim())}return{type:"heading",raw:t[0],depth:t[1].length,text:e,tokens:this.lexer.inline(e)}}}hr(e){const t=this.rules.block.hr.exec(e);if(t)return{type:"hr",raw:t[0]}}blockquote(e){const t=this.rules.block.blockquote.exec(e);if(t){const e=t[0].replace(/^ *>[ \t]?/gm,""),r=this.lexer.state.top;this.lexer.state.top=!0;const n=this.lexer.blockTokens(e);return this.lexer.state.top=r,{type:"blockquote",raw:t[0],tokens:n,text:e}}}list(e){let t=this.rules.block.list.exec(e);if(t){let r,n,i,o,s,a,l,c,u,p,d,f,h=t[1].trim();const m=h.length>1,g={type:"list",raw:"",ordered:m,start:m?+h.slice(0,-1):"",loose:!1,items:[]};h=m?`\\d{1,9}\\${h.slice(-1)}`:`\\${h}`,this.options.pedantic&&(h=m?h:"[*+-]");const y=new RegExp(`^( {0,3}${h})((?:[\t ][^\\n]*)?(?:\\n|$))`);for(;e&&(f=!1,t=y.exec(e))&&!this.rules.block.hr.test(e);){if(r=t[0],e=e.substring(r.length),c=t[2].split("\n",1)[0].replace(/^\t+/,e=>" ".repeat(3*e.length)),u=e.split("\n",1)[0],this.options.pedantic?(o=2,d=c.trimLeft()):(o=t[2].search(/[^ ]/),o=o>4?1:o,d=c.slice(o),o+=t[1].length),a=!1,!c&&/^ *$/.test(u)&&(r+=u+"\n",e=e.substring(u.length+1),f=!0),!f){const t=new RegExp(`^ {0,${Math.min(3,o-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),n=new RegExp(`^ {0,${Math.min(3,o-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),i=new RegExp(`^ {0,${Math.min(3,o-1)}}(?:\`\`\`|~~~)`),s=new RegExp(`^ {0,${Math.min(3,o-1)}}#`);for(;e&&(p=e.split("\n",1)[0],u=p,this.options.pedantic&&(u=u.replace(/^ {1,4}(?=( {4})*[^ ])/g," ")),!i.test(u))&&!s.test(u)&&!t.test(u)&&!n.test(e);){if(u.search(/[^ ]/)>=o||!u.trim())d+="\n"+u.slice(o);else{if(a)break;if(c.search(/[^ ]/)>=4)break;if(i.test(c))break;if(s.test(c))break;if(n.test(c))break;d+="\n"+u}a||u.trim()||(a=!0),r+=p+"\n",e=e.substring(p.length+1),c=u.slice(o)}}g.loose||(l?g.loose=!0:/\n *\n *$/.test(r)&&(l=!0)),this.options.gfm&&(n=/^\[[ xX]\] /.exec(d),n&&(i="[ ] "!==n[0],d=d.replace(/^\[[ xX]\] +/,""))),g.items.push({type:"list_item",raw:r,task:!!n,checked:i,loose:!1,text:d}),g.raw+=r}g.items[g.items.length-1].raw=r.trimRight(),g.items[g.items.length-1].text=d.trimRight(),g.raw=g.raw.trimRight();const b=g.items.length;for(s=0;s"space"===e.type),t=e.length>0&&e.some(e=>/\n.*\n/.test(e.raw));g.loose=t}if(g.loose)for(s=0;s$/,"$1").replace(this.rules.inline._escapes,"$1"):"",n=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline._escapes,"$1"):t[3];return{type:"def",tag:e,raw:t[0],href:r,title:n}}}table(e){const t=this.rules.block.table.exec(e);if(t){const e={type:"table",header:ll(t[1]).map(e=>({text:e})),align:t[2].replace(/^ *|\| *$/g,"").split(/ *\| */),rows:t[3]&&t[3].trim()?t[3].replace(/\n[ \t]*$/,"").split("\n"):[]};if(e.header.length===e.align.length){e.raw=t[0];let r,n,i,o,s=e.align.length;for(r=0;r({text:e}));for(s=e.header.length,n=0;n/i.test(t[0])&&(this.lexer.state.inLink=!1),!this.lexer.state.inRawBlock&&/^<(pre|code|kbd|script)(\s|>)/i.test(t[0])?this.lexer.state.inRawBlock=!0:this.lexer.state.inRawBlock&&/^<\/(pre|code|kbd|script)(\s|>)/i.test(t[0])&&(this.lexer.state.inRawBlock=!1),{type:this.options.sanitize?"text":"html",raw:t[0],inLink:this.lexer.state.inLink,inRawBlock:this.lexer.state.inRawBlock,text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(t[0]):Ka(t[0]):t[0]}}link(e){const t=this.rules.inline.link.exec(e);if(t){const e=t[2].trim();if(!this.options.pedantic&&/^$/.test(e))return;const t=cl(e.slice(0,-1),"\\");if((e.length-t.length)%2==0)return}else{const e=function(e,t){if(-1===e.indexOf(t[1]))return-1;const r=e.length;let n=0,i=0;for(;i-1){const r=(0===t[0].indexOf("!")?5:4)+t[1].length+e;t[2]=t[2].substring(0,e),t[0]=t[0].substring(0,r).trim(),t[3]=""}}let r=t[2],n="";if(this.options.pedantic){const e=/^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(r);e&&(r=e[1],n=e[3])}else n=t[3]?t[3].slice(1,-1):"";return r=r.trim(),/^$/.test(e)?r.slice(1):r.slice(1,-1)),pl(t,{href:r?r.replace(this.rules.inline._escapes,"$1"):r,title:n?n.replace(this.rules.inline._escapes,"$1"):n},t[0],this.lexer)}}reflink(e,t){let r;if((r=this.rules.inline.reflink.exec(e))||(r=this.rules.inline.nolink.exec(e))){let e=(r[2]||r[1]).replace(/\s+/g," ");if(e=t[e.toLowerCase()],!e){const e=r[0].charAt(0);return{type:"text",raw:e,text:e}}return pl(r,e,r[0],this.lexer)}}emStrong(e,t,r=""){let n=this.rules.inline.emStrong.lDelim.exec(e);if(!n)return;if(n[3]&&r.match(/[\p{L}\p{N}]/u))return;const i=n[1]||n[2]||"";if(!i||i&&(""===r||this.rules.inline.punctuation.exec(r))){const r=n[0].length-1;let i,o,s=r,a=0;const l="*"===n[0][0]?this.rules.inline.emStrong.rDelimAst:this.rules.inline.emStrong.rDelimUnd;for(l.lastIndex=0,t=t.slice(-1*e.length+r);null!=(n=l.exec(t));){if(i=n[1]||n[2]||n[3]||n[4]||n[5]||n[6],!i)continue;if(o=i.length,n[3]||n[4]){s+=o;continue}if((n[5]||n[6])&&r%3&&!((r+o)%3)){a+=o;continue}if(s-=o,s>0)continue;o=Math.min(o,o+s+a);const t=e.slice(0,r+n.index+(n[0].length-i.length)+o);if(Math.min(r,o)%2){const e=t.slice(1,-1);return{type:"em",raw:t,text:e,tokens:this.lexer.inlineTokens(e)}}const l=t.slice(2,-2);return{type:"strong",raw:t,text:l,tokens:this.lexer.inlineTokens(l)}}}}codespan(e){const t=this.rules.inline.code.exec(e);if(t){let e=t[2].replace(/\n/g," ");const r=/[^ ]/.test(e),n=/^ /.test(e)&&/ $/.test(e);return r&&n&&(e=e.substring(1,e.length-1)),e=Ka(e,!0),{type:"codespan",raw:t[0],text:e}}}br(e){const t=this.rules.inline.br.exec(e);if(t)return{type:"br",raw:t[0]}}del(e){const t=this.rules.inline.del.exec(e);if(t)return{type:"del",raw:t[0],text:t[2],tokens:this.lexer.inlineTokens(t[2])}}autolink(e,t){const r=this.rules.inline.autolink.exec(e);if(r){let e,n;return"@"===r[2]?(e=Ka(this.options.mangle?t(r[1]):r[1]),n="mailto:"+e):(e=Ka(r[1]),n=e),{type:"link",raw:r[0],text:e,href:n,tokens:[{type:"text",raw:e,text:e}]}}}url(e,t){let r;if(r=this.rules.inline.url.exec(e)){let e,n;if("@"===r[2])e=Ka(this.options.mangle?t(r[0]):r[0]),n="mailto:"+e;else{let t;do{t=r[0],r[0]=this.rules.inline._backpedal.exec(r[0])[0]}while(t!==r[0]);e=Ka(r[0]),n="www."===r[1]?"http://"+r[0]:r[0]}return{type:"link",raw:r[0],text:e,href:n,tokens:[{type:"text",raw:e,text:e}]}}}inlineText(e,t){const r=this.rules.inline.text.exec(e);if(r){let e;return e=this.lexer.state.inRawBlock?this.options.sanitize?this.options.sanitizer?this.options.sanitizer(r[0]):Ka(r[0]):r[0]:Ka(this.options.smartypants?t(r[0]):r[0]),{type:"text",raw:r[0],text:e}}}}const fl={newline:/^(?: *(?:\n|$))+/,code:/^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,fences:/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,hr:/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,heading:/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,blockquote:/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,list:/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/,html:"^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))",def:/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,table:al,lheading:/^((?:.|\n(?!\n))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,_paragraph:/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,text:/^[^\n]+/,_label:/(?!\s*\])(?:\\.|[^\[\]\\])+/,_title:/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/};fl.def=Za(fl.def).replace("label",fl._label).replace("title",fl._title).getRegex(),fl.bullet=/(?:[*+-]|\d{1,9}[.)])/,fl.listItemStart=Za(/^( *)(bull) */).replace("bull",fl.bullet).getRegex(),fl.list=Za(fl.list).replace(/bull/g,fl.bullet).replace("hr","\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def","\\n+(?="+fl.def.source+")").getRegex(),fl._tag="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",fl._comment=/|$)/,fl.html=Za(fl.html,"i").replace("comment",fl._comment).replace("tag",fl._tag).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),fl.paragraph=Za(fl._paragraph).replace("hr",fl.hr).replace("heading"," {0,3}#{1,6} ").replace("|lheading","").replace("|table","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",fl._tag).getRegex(),fl.blockquote=Za(fl.blockquote).replace("paragraph",fl.paragraph).getRegex(),fl.normal={...fl},fl.gfm={...fl.normal,table:"^ *([^\\n ].*\\|.*)\\n {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"},fl.gfm.table=Za(fl.gfm.table).replace("hr",fl.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",fl._tag).getRegex(),fl.gfm.paragraph=Za(fl._paragraph).replace("hr",fl.hr).replace("heading"," {0,3}#{1,6} ").replace("|lheading","").replace("table",fl.gfm.table).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",fl._tag).getRegex(),fl.pedantic={...fl.normal,html:Za("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment",fl._comment).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:al,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:Za(fl.normal._paragraph).replace("hr",fl.hr).replace("heading"," *#{1,6} *[^\n]").replace("lheading",fl.lheading).replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").getRegex()};const hl={escape:/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,autolink:/^<(scheme:[^\s\x00-\x1f<>]*|email)>/,url:al,tag:"^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^",link:/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,reflink:/^!?\[(label)\]\[(ref)\]/,nolink:/^!?\[(ref)\](?:\[\])?/,reflinkSearch:"reflink|nolink(?!\\()",emStrong:{lDelim:/^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,rDelimAst:/^(?:[^_*\\]|\\.)*?\_\_(?:[^_*\\]|\\.)*?\*(?:[^_*\\]|\\.)*?(?=\_\_)|(?:[^*\\]|\\.)+(?=[^*])|[punct_](\*+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|(?:[^punct*_\s\\]|\\.)(\*+)(?=[^punct*_\s])/,rDelimUnd:/^(?:[^_*\\]|\\.)*?\*\*(?:[^_*\\]|\\.)*?\_(?:[^_*\\]|\\.)*?(?=\*\*)|(?:[^_\\]|\\.)+(?=[^_])|[punct*](\_+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/},code:/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,br:/^( {2,}|\\)\n(?!\s*$)/,del:al,text:/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\.5&&(r="x"+r.toString(16)),n+="&#"+r+";";return n}hl._punctuation="!\"#$%&'()+\\-.,/:;<=>?@\\[\\]`^{|}~",hl.punctuation=Za(hl.punctuation).replace(/punctuation/g,hl._punctuation).getRegex(),hl.blockSkip=/\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g,hl.escapedEmSt=/(?:^|[^\\])(?:\\\\)*\\[*_]/g,hl._comment=Za(fl._comment).replace("(?:--\x3e|$)","--\x3e").getRegex(),hl.emStrong.lDelim=Za(hl.emStrong.lDelim).replace(/punct/g,hl._punctuation).getRegex(),hl.emStrong.rDelimAst=Za(hl.emStrong.rDelimAst,"g").replace(/punct/g,hl._punctuation).getRegex(),hl.emStrong.rDelimUnd=Za(hl.emStrong.rDelimUnd,"g").replace(/punct/g,hl._punctuation).getRegex(),hl._escapes=/\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g,hl._scheme=/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/,hl._email=/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/,hl.autolink=Za(hl.autolink).replace("scheme",hl._scheme).replace("email",hl._email).getRegex(),hl._attribute=/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/,hl.tag=Za(hl.tag).replace("comment",hl._comment).replace("attribute",hl._attribute).getRegex(),hl._label=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,hl._href=/<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/,hl._title=/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/,hl.link=Za(hl.link).replace("label",hl._label).replace("href",hl._href).replace("title",hl._title).getRegex(),hl.reflink=Za(hl.reflink).replace("label",hl._label).replace("ref",fl._label).getRegex(),hl.nolink=Za(hl.nolink).replace("ref",fl._label).getRegex(),hl.reflinkSearch=Za(hl.reflinkSearch,"g").replace("reflink",hl.reflink).replace("nolink",hl.nolink).getRegex(),hl.normal={...hl},hl.pedantic={...hl.normal,strong:{start:/^__|\*\*/,middle:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,endAst:/\*\*(?!\*)/g,endUnd:/__(?!_)/g},em:{start:/^_|\*/,middle:/^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,endAst:/\*(?!\*)/g,endUnd:/_(?!_)/g},link:Za(/^!?\[(label)\]\((.*?)\)/).replace("label",hl._label).getRegex(),reflink:Za(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",hl._label).getRegex()},hl.gfm={...hl.normal,escape:Za(hl.escape).replace("])","~|])").getRegex(),_extended_email:/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,url:/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,_backpedal:/(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\t+" ".repeat(r.length));e;)if(!(this.options.extensions&&this.options.extensions.block&&this.options.extensions.block.some(n=>!!(r=n.call({lexer:this},e,t))&&(e=e.substring(r.raw.length),t.push(r),!0))))if(r=this.tokenizer.space(e))e=e.substring(r.raw.length),1===r.raw.length&&t.length>0?t[t.length-1].raw+="\n":t.push(r);else if(r=this.tokenizer.code(e))e=e.substring(r.raw.length),n=t[t.length-1],!n||"paragraph"!==n.type&&"text"!==n.type?t.push(r):(n.raw+="\n"+r.raw,n.text+="\n"+r.text,this.inlineQueue[this.inlineQueue.length-1].src=n.text);else if(r=this.tokenizer.fences(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.heading(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.hr(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.blockquote(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.list(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.html(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.def(e))e=e.substring(r.raw.length),n=t[t.length-1],!n||"paragraph"!==n.type&&"text"!==n.type?this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title}):(n.raw+="\n"+r.raw,n.text+="\n"+r.raw,this.inlineQueue[this.inlineQueue.length-1].src=n.text);else if(r=this.tokenizer.table(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.lheading(e))e=e.substring(r.raw.length),t.push(r);else{if(i=e,this.options.extensions&&this.options.extensions.startBlock){let t=1/0;const r=e.slice(1);let n;this.options.extensions.startBlock.forEach(function(e){n=e.call({lexer:this},r),"number"==typeof n&&n>=0&&(t=Math.min(t,n))}),t<1/0&&t>=0&&(i=e.substring(0,t+1))}if(this.state.top&&(r=this.tokenizer.paragraph(i)))n=t[t.length-1],o&&"paragraph"===n.type?(n.raw+="\n"+r.raw,n.text+="\n"+r.text,this.inlineQueue.pop(),this.inlineQueue[this.inlineQueue.length-1].src=n.text):t.push(r),o=i.length!==e.length,e=e.substring(r.raw.length);else if(r=this.tokenizer.text(e))e=e.substring(r.raw.length),n=t[t.length-1],n&&"text"===n.type?(n.raw+="\n"+r.raw,n.text+="\n"+r.text,this.inlineQueue.pop(),this.inlineQueue[this.inlineQueue.length-1].src=n.text):t.push(r);else if(e){const t="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(t);break}throw new Error(t)}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){let r,n,i,o,s,a,l=e;if(this.tokens.links){const e=Object.keys(this.tokens.links);if(e.length>0)for(;null!=(o=this.tokenizer.rules.inline.reflinkSearch.exec(l));)e.includes(o[0].slice(o[0].lastIndexOf("[")+1,-1))&&(l=l.slice(0,o.index)+"["+ul("a",o[0].length-2)+"]"+l.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;null!=(o=this.tokenizer.rules.inline.blockSkip.exec(l));)l=l.slice(0,o.index)+"["+ul("a",o[0].length-2)+"]"+l.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);for(;null!=(o=this.tokenizer.rules.inline.escapedEmSt.exec(l));)l=l.slice(0,o.index+o[0].length-2)+"++"+l.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex),this.tokenizer.rules.inline.escapedEmSt.lastIndex--;for(;e;)if(s||(a=""),s=!1,!(this.options.extensions&&this.options.extensions.inline&&this.options.extensions.inline.some(n=>!!(r=n.call({lexer:this},e,t))&&(e=e.substring(r.raw.length),t.push(r),!0))))if(r=this.tokenizer.escape(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.tag(e))e=e.substring(r.raw.length),n=t[t.length-1],n&&"text"===r.type&&"text"===n.type?(n.raw+=r.raw,n.text+=r.text):t.push(r);else if(r=this.tokenizer.link(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.reflink(e,this.tokens.links))e=e.substring(r.raw.length),n=t[t.length-1],n&&"text"===r.type&&"text"===n.type?(n.raw+=r.raw,n.text+=r.text):t.push(r);else if(r=this.tokenizer.emStrong(e,l,a))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.codespan(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.br(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.del(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.autolink(e,gl))e=e.substring(r.raw.length),t.push(r);else if(this.state.inLink||!(r=this.tokenizer.url(e,gl))){if(i=e,this.options.extensions&&this.options.extensions.startInline){let t=1/0;const r=e.slice(1);let n;this.options.extensions.startInline.forEach(function(e){n=e.call({lexer:this},r),"number"==typeof n&&n>=0&&(t=Math.min(t,n))}),t<1/0&&t>=0&&(i=e.substring(0,t+1))}if(r=this.tokenizer.inlineText(i,ml))e=e.substring(r.raw.length),"_"!==r.raw.slice(-1)&&(a=r.raw.slice(-1)),s=!0,n=t[t.length-1],n&&"text"===n.type?(n.raw+=r.raw,n.text+=r.text):t.push(r);else if(e){const t="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(t);break}throw new Error(t)}}else e=e.substring(r.raw.length),t.push(r);return t}}class bl{constructor(e){this.options=e||Ua}code(e,t,r){const n=(t||"").match(/\S*/)[0];if(this.options.highlight){const t=this.options.highlight(e,n);null!=t&&t!==e&&(r=!0,e=t)}return e=e.replace(/\n$/,"")+"\n",n?'
'+(r?e:Ka(e,!0))+"
\n":"
"+(r?e:Ka(e,!0))+"
\n"}blockquote(e){return`
\n${e}
\n`}html(e){return e}heading(e,t,r,n){return this.options.headerIds?`${e}\n`:`${e}\n`}hr(){return this.options.xhtml?"
\n":"
\n"}list(e,t,r){const n=t?"ol":"ul";return"<"+n+(t&&1!==r?' start="'+r+'"':"")+">\n"+e+"\n"}listitem(e){return`
  • ${e}
    • \n`}checkbox(e){return" "}paragraph(e){return`

    ${e}

    \n`}table(e,t){return t&&(t=`${t}`),"\n\n"+e+"\n"+t+"
    \n"}tablerow(e){return`\n${e}\n`}tablecell(e,t){const r=t.header?"th":"td";return(t.align?`<${r} align="${t.align}">`:`<${r}>`)+e+`\n`}strong(e){return`${e}`}em(e){return`${e}`}codespan(e){return`${e}`}br(){return this.options.xhtml?"
    ":"
    "}del(e){return`${e}`}link(e,t,r){if(null===(e=rl(this.options.sanitize,this.options.baseUrl,e)))return r;let n='",n}image(e,t,r){if(null===(e=rl(this.options.sanitize,this.options.baseUrl,e)))return r;let n=`${r}":">",n}text(e){return e}}class vl{strong(e){return e}em(e){return e}codespan(e){return e}del(e){return e}html(e){return e}text(e){return e}link(e,t,r){return""+r}image(e,t,r){return""+r}br(){return""}}class xl{constructor(){this.seen={}}serialize(e){return e.toLowerCase().trim().replace(/<[!\/a-z].*?>/gi,"").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g,"").replace(/\s/g,"-")}getNextSafeSlug(e,t){let r=e,n=0;if(this.seen.hasOwnProperty(r)){n=this.seen[e];do{n++,r=e+"-"+n}while(this.seen.hasOwnProperty(r))}return t||(this.seen[e]=n,this.seen[r]=0),r}slug(e,t={}){const r=this.serialize(e);return this.getNextSafeSlug(r,t.dryrun)}}class wl{constructor(e){this.options=e||Ua,this.options.renderer=this.options.renderer||new bl,this.renderer=this.options.renderer,this.renderer.options=this.options,this.textRenderer=new vl,this.slugger=new xl}static parse(e,t){return new wl(t).parse(e)}static parseInline(e,t){return new wl(t).parseInline(e)}parse(e,t=!0){let r,n,i,o,s,a,l,c,u,p,d,f,h,m,g,y,b,v,x,w="";const k=e.length;for(r=0;r0&&"paragraph"===g.tokens[0].type?(g.tokens[0].text=v+" "+g.tokens[0].text,g.tokens[0].tokens&&g.tokens[0].tokens.length>0&&"text"===g.tokens[0].tokens[0].type&&(g.tokens[0].tokens[0].text=v+" "+g.tokens[0].tokens[0].text)):g.tokens.unshift({type:"text",text:v}):m+=v),m+=this.parse(g.tokens,h),u+=this.renderer.listitem(m,b,y);w+=this.renderer.list(u,d,f);continue;case"html":w+=this.renderer.html(p.text);continue;case"paragraph":w+=this.renderer.paragraph(this.parseInline(p.tokens));continue;case"text":for(u=p.tokens?this.parseInline(p.tokens):p.text;r+1{"function"==typeof n&&(i=n,n=null);const o={...n},s=function(e,t,r){return n=>{if(n.message+="\nPlease report this to https://github.com/markedjs/marked.",e){const e="

    An error occurred:

    "+Ka(n.message+"",!0)+"
    ";return t?Promise.resolve(e):r?void r(null,e):e}if(t)return Promise.reject(n);if(!r)throw n;r(n)}}((n={...El.defaults,...o}).silent,n.async,i);if(null==r)return s(new Error("marked(): input parameter is undefined or null"));if("string"!=typeof r)return s(new Error("marked(): input parameter is of type "+Object.prototype.toString.call(r)+", string expected"));if(function(e){e&&e.sanitize&&!e.silent&&console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options")}(n),n.hooks&&(n.hooks.options=n),i){const o=n.highlight;let a;try{n.hooks&&(r=n.hooks.preprocess(r)),a=e(r,n)}catch(e){return s(e)}const l=function(e){let r;if(!e)try{n.walkTokens&&El.walkTokens(a,n.walkTokens),r=t(a,n),n.hooks&&(r=n.hooks.postprocess(r))}catch(t){e=t}return n.highlight=o,e?s(e):i(null,r)};if(!o||o.length<3)return l();if(delete n.highlight,!a.length)return l();let c=0;return El.walkTokens(a,function(e){"code"===e.type&&(c++,setTimeout(()=>{o(e.text,e.lang,function(t,r){if(t)return l(t);null!=r&&r!==e.text&&(e.text=r,e.escaped=!0),c--,0===c&&l()})},0))}),void(0===c&&l())}if(n.async)return Promise.resolve(n.hooks?n.hooks.preprocess(r):r).then(t=>e(t,n)).then(e=>n.walkTokens?Promise.all(El.walkTokens(e,n.walkTokens)).then(()=>e):e).then(e=>t(e,n)).then(e=>n.hooks?n.hooks.postprocess(e):e).catch(s);try{n.hooks&&(r=n.hooks.preprocess(r));const i=e(r,n);n.walkTokens&&El.walkTokens(i,n.walkTokens);let o=t(i,n);return n.hooks&&(o=n.hooks.postprocess(o)),o}catch(e){return s(e)}}}function El(e,t,r){return Sl(yl.lex,wl.parse)(e,t,r)}El.options=El.setOptions=function(e){var t;return El.defaults={...El.defaults,...e},t=El.defaults,Ua=t,El},El.getDefaults=function(){return{async:!1,baseUrl:null,breaks:!1,extensions:null,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,hooks:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:null,sanitize:!1,sanitizer:null,silent:!1,smartypants:!1,tokenizer:null,walkTokens:null,xhtml:!1}},El.defaults=Ua,El.use=function(...e){const t=El.defaults.extensions||{renderers:{},childTokens:{}};e.forEach(e=>{const r={...e};if(r.async=El.defaults.async||r.async||!1,e.extensions&&(e.extensions.forEach(e=>{if(!e.name)throw new Error("extension name required");if(e.renderer){const r=t.renderers[e.name];t.renderers[e.name]=r?function(...t){let n=e.renderer.apply(this,t);return!1===n&&(n=r.apply(this,t)),n}:e.renderer}if(e.tokenizer){if(!e.level||"block"!==e.level&&"inline"!==e.level)throw new Error("extension level must be 'block' or 'inline'");t[e.level]?t[e.level].unshift(e.tokenizer):t[e.level]=[e.tokenizer],e.start&&("block"===e.level?t.startBlock?t.startBlock.push(e.start):t.startBlock=[e.start]:"inline"===e.level&&(t.startInline?t.startInline.push(e.start):t.startInline=[e.start]))}e.childTokens&&(t.childTokens[e.name]=e.childTokens)}),r.extensions=t),e.renderer){const t=El.defaults.renderer||new bl;for(const r in e.renderer){const n=t[r];t[r]=(...i)=>{let o=e.renderer[r].apply(t,i);return!1===o&&(o=n.apply(t,i)),o}}r.renderer=t}if(e.tokenizer){const t=El.defaults.tokenizer||new dl;for(const r in e.tokenizer){const n=t[r];t[r]=(...i)=>{let o=e.tokenizer[r].apply(t,i);return!1===o&&(o=n.apply(t,i)),o}}r.tokenizer=t}if(e.hooks){const t=El.defaults.hooks||new kl;for(const r in e.hooks){const n=t[r];kl.passThroughHooks.has(r)?t[r]=i=>{if(El.defaults.async)return Promise.resolve(e.hooks[r].call(t,i)).then(e=>n.call(t,e));const o=e.hooks[r].call(t,i);return n.call(t,o)}:t[r]=(...i)=>{let o=e.hooks[r].apply(t,i);return!1===o&&(o=n.apply(t,i)),o}}r.hooks=t}if(e.walkTokens){const t=El.defaults.walkTokens;r.walkTokens=function(r){let n=[];return n.push(e.walkTokens.call(this,r)),t&&(n=n.concat(t.call(this,r))),n}}El.setOptions(r)})},El.walkTokens=function(e,t){let r=[];for(const n of e)switch(r=r.concat(t.call(El,n)),n.type){case"table":for(const e of n.header)r=r.concat(El.walkTokens(e.tokens,t));for(const e of n.rows)for(const n of e)r=r.concat(El.walkTokens(n.tokens,t));break;case"list":r=r.concat(El.walkTokens(n.items,t));break;default:El.defaults.extensions&&El.defaults.extensions.childTokens&&El.defaults.extensions.childTokens[n.type]?El.defaults.extensions.childTokens[n.type].forEach(function(e){r=r.concat(El.walkTokens(n[e],t))}):n.tokens&&(r=r.concat(El.walkTokens(n.tokens,t)))}return r},El.parseInline=Sl(yl.lexInline,wl.parseInline),El.Parser=wl,El.parser=wl.parse,El.Renderer=bl,El.TextRenderer=vl,El.Lexer=yl,El.lexer=yl.lex,El.Tokenizer=dl,El.Slugger=xl,El.Hooks=kl,El.parse=El,El.options,El.setOptions,El.use,El.walkTokens,El.parseInline;var Ol=Object.defineProperty,_l=Object.defineProperties,Pl=Object.getOwnPropertyDescriptors,$l=Object.getOwnPropertySymbols,Al=Object.prototype.hasOwnProperty,Cl=Object.prototype.propertyIsEnumerable,jl=(e,t,r)=>t in e?Ol(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Tl=(e,t)=>{for(var r in t||(t={}))Al.call(t,r)&&jl(e,r,t[r]);if($l)for(var r of $l(t))Cl.call(t,r)&&jl(e,r,t[r]);return e},Nl=(e,t)=>_l(e,Pl(t));const Il=new El.Renderer;El.setOptions({renderer:Il,highlight:(e,t)=>ka(e,t)});const Rl="(?:^ {0,3}\x3c!-- ReDoc-Inject:\\s+?<({component}).*?/?>\\s+?--\x3e\\s*$|(?:^ {0,3}<({component})([\\s\\S]*?)>([\\s\\S]*?)|^ {0,3}<({component})([\\s\\S]*?)(?:/>|\\n{2,})))";class Ll{constructor(e,t){this.options=e,this.parentId=t,this.headings=[],this.headingRule=(e,t,r,n)=>(1===t?this.currentTopHeading=this.saveHeading(e,t):2===t&&this.saveHeading(e,t,this.currentTopHeading&&this.currentTopHeading.items,this.currentTopHeading&&this.currentTopHeading.id),this.originalHeadingRule(e,t,r,n)),this.parentId=t,this.parser=new El.Parser,this.headingEnhanceRenderer=new El.Renderer,this.originalHeadingRule=this.headingEnhanceRenderer.heading.bind(this.headingEnhanceRenderer),this.headingEnhanceRenderer.heading=this.headingRule}static containsComponent(e,t){return new RegExp(Rl.replace(/{component}/g,t),"gmi").test(e)}static getTextBeforeHading(e,t){const r=e.search(new RegExp(`^##?\\s+${t}`,"m"));return r>-1?e.substring(0,r):e}saveHeading(e,t,r=this.headings,n){e=e.replace(/&#(\d+);/g,(e,t)=>String.fromCharCode(parseInt(t,10))).replace(/&/g,"&").replace(/"/g,'"');const i={id:n?`${n}/${li(e)}`:`${this.parentId||"section"}/${li(e)}`,name:e,level:t,items:[]};return r.push(i),i}flattenHeadings(e){if(void 0===e)return[];const t=[];for(const r of e)t.push(r),t.push(...this.flattenHeadings(r.items));return t}attachHeadingsDescriptions(e){const t=e=>new RegExp(`##?\\s+${e.name.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}s*(\n|\r\n|$|s*)`),r=this.flattenHeadings(this.headings);if(r.length<1)return;let n=r[0],i=t(n),o=e.search(i);for(let s=1;s-1&&(this.description=this.description.substring(0,r)),this.downloadUrls=this.getDownloadUrls(),this.downloadFileName=this.getDownloadFileName()}getDownloadUrls(){return(this.options.downloadUrls?this.options.downloadUrls.map(({title:e,url:t})=>({title:e||hi("download"),url:this.getDownloadLink(t)})):[{title:hi("download"),url:this.getDownloadLink(this.options.downloadDefinitionUrl)}]).filter(({title:e,url:t})=>e&&t)}getDownloadLink(e){if(e)return e;if(this.parser.specUrl)return this.parser.specUrl;if(Qn&&window.Blob&&window.URL&&window.URL.createObjectURL){const e=new Blob([JSON.stringify(this.parser.spec,null,2)],{type:"application/json"});return window.URL.createObjectURL(e)}}getDownloadFileName(){return this.parser.specUrl||this.options.downloadDefinitionUrl?this.options.downloadFileName:this.options.downloadFileName||"openapi.json"}}var zl=Object.defineProperty,Fl=Object.defineProperties,Bl=Object.getOwnPropertyDescriptors,Ul=Object.getOwnPropertySymbols,ql=Object.prototype.hasOwnProperty,Vl=Object.prototype.propertyIsEnumerable,Wl=(e,t,r)=>t in e?zl(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;class Hl{constructor(e,t){const r=t.spec.components&&t.spec.components.securitySchemes||{};this.schemes=Object.keys(e||{}).map(n=>{const{resolved:i}=t.deref(r[n]),o=e[n]||[];if(!i)return void console.warn(`Non existing security scheme referenced: ${n}. Skipping`);const s=i["x-displayName"]||n;return((e,t)=>Fl(e,Bl(t)))(((e,t)=>{for(var r in t||(t={}))ql.call(t,r)&&Wl(e,r,t[r]);if(Ul)for(var r of Ul(t))Vl.call(t,r)&&Wl(e,r,t[r]);return e})({},i),{id:n,sectionId:n,displayName:s,scopes:o})}).filter(e=>void 0!==e)}}var Gl=Object.defineProperty,Yl=Object.defineProperties,Kl=Object.getOwnPropertyDescriptor,Ql=Object.getOwnPropertyDescriptors,Xl=Object.getOwnPropertySymbols,Jl=Object.prototype.hasOwnProperty,Zl=Object.prototype.propertyIsEnumerable,ec=(e,t,r)=>t in e?Gl(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,tc=(e,t)=>{for(var r in t||(t={}))Jl.call(t,r)&&ec(e,r,t[r]);if(Xl)for(var r of Xl(t))Zl.call(t,r)&&ec(e,r,t[r]);return e},rc=(e,t)=>Yl(e,Ql(t)),nc=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Kl(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Gl(t,r,o),o};class ic{constructor(e,t,r,n,i){this.expanded=!1,this.operations=[],ir(this),this.name=t;const{resolved:o}=e.deref(r);for(const r of Object.keys(o)){const s=o[r],a=Object.keys(s).filter(Xs);for(const o of a){const a=s[o],l=new ap(e,rc(tc({},a),{pathName:r,pointer:Ls.compile([n,t,r,o]),httpVerb:o,pathParameters:s.parameters||[],pathServers:s.servers}),void 0,i,!0);this.operations.push(l)}}}toggle(){this.expanded=!this.expanded}}nc([Ce],ic.prototype,"expanded",2),nc([Ct],ic.prototype,"toggle",1);var oc=Object.defineProperty,sc=Object.defineProperties,ac=Object.getOwnPropertyDescriptors,lc=Object.getOwnPropertySymbols,cc=Object.prototype.hasOwnProperty,uc=Object.prototype.propertyIsEnumerable,pc=(e,t,r)=>t in e?oc(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,dc=(e,t)=>{for(var r in t||(t={}))cc.call(t,r)&&pc(e,r,t[r]);if(lc)for(var r of lc(t))uc.call(t,r)&&pc(e,r,t[r]);return e},fc=(e,t)=>sc(e,ac(t)),hc=(e,t)=>{var r={};for(var n in e)cc.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&lc)for(var n of lc(e))t.indexOf(n)<0&&uc.call(e,n)&&(r[n]=e[n]);return r};function mc(e,t){return t&&e[e.length-1]!==t?[...e,t]:e}function gc(e,t){return t?e.concat(t):e}class yc{constructor(e,t,r=new _i({})){this.options=r,this.allowMergeRefs=!1,this.byRef=e=>{let t;if(this.spec){"#"!==e.charAt(0)&&(e="#"+e),e=decodeURIComponent(e);try{t=Ls.get(this.spec,e)}catch(e){}return t||{}}},this.validate(e),this.spec=e,this.allowMergeRefs=e.openapi.startsWith("3.1");const n=Qn?window.location.href:"";"string"==typeof t&&(this.specUrl=n?new URL(t,n).href:t)}validate(e){if(void 0===e.openapi)throw new Error("Document must be valid OpenAPI 3.0.0 definition")}isRef(e){return!!e&&void 0!==e.$ref&&null!==e.$ref}deref(e,t=[],r=!1){const n=null==e?void 0:e["x-refsStack"];if(t=gc(t,n),this.isRef(e)){const n=la(e.$ref);if(n&&this.options.ignoreNamedSchemas.has(n))return{resolved:{type:"object",title:n},refsStack:t};let i=this.byRef(e.$ref);if(!i)throw new Error(`Failed to resolve $ref "${e.$ref}"`);let o=t;if(t.includes(e.$ref)||t.length>999)i=Object.assign({},i,{"x-circular-ref":!0});else if(this.isRef(i)){const e=this.deref(i,t,r);o=e.refsStack,i=e.resolved}return o=mc(t,e.$ref),i=this.allowMergeRefs?this.mergeRefs(e,i,r):i,{resolved:i,refsStack:o}}return{resolved:e,refsStack:gc(t,n)}}mergeRefs(e,t,r){const n=e,{$ref:i}=n,o=hc(n,["$ref"]),s=Object.keys(o);if(0===s.length)return t;if(r&&s.some(e=>!["description","title","externalDocs","x-refsStack","x-parentRefs","readOnly","writeOnly"].includes(e))){const e=o,{description:r,title:n,readOnly:i,writeOnly:s}=e;return{allOf:[{description:r,title:n,readOnly:i,writeOnly:s},t,hc(e,["description","title","readOnly","writeOnly"])]}}return dc(dc({},t),o)}mergeAllOf(e,t,r){var n;if(e["x-circular-ref"])return e;if(void 0===(e=this.hoistOneOfs(e,r)).allOf)return e;let i=fc(dc({},e),{"x-parentRefs":[],allOf:void 0,title:e.title||la(t)});void 0!==i.properties&&"object"==typeof i.properties&&(i.properties=dc({},i.properties)),void 0!==i.items&&"object"==typeof i.items&&(i.items=dc({},i.items));const o=function(e){const t=new Set;return e.filter(e=>{const r=e.$ref;return!r||r&&!t.has(r)&&t.add(r)})}(e.allOf.map(e=>{var t;const{resolved:n,refsStack:o}=this.deref(e,r,!0),s=e.$ref||void 0,a=this.mergeAllOf(n,s,o);if(!a["x-circular-ref"]||!a.allOf)return s&&(null==(t=i["x-parentRefs"])||t.push(...a["x-parentRefs"]||[],s)),{$ref:s,refsStack:mc(o,s),schema:a}}).filter(e=>void 0!==e));for(const{schema:e,refsStack:r}of o){const o=e,{type:s,enum:a,properties:l,items:c,required:u,title:p,description:d,readOnly:f,writeOnly:h,oneOf:m,anyOf:g,"x-circular-ref":y}=o,b=hc(o,["type","enum","properties","items","required","title","description","readOnly","writeOnly","oneOf","anyOf","x-circular-ref"]);if(i.type!==s&&void 0!==i.type&&void 0!==s&&console.warn(`Incompatible types in allOf at "${t}": "${i.type}" and "${s}"`),void 0!==s&&(Array.isArray(s)&&Array.isArray(i.type)?i.type=[...s,...i.type]:i.type=s),void 0!==a&&(Array.isArray(a)&&Array.isArray(i.enum)?i.enum=Array.from(new Set([...a,...i.enum])):i.enum=a),void 0!==l&&"object"==typeof l){i.properties=i.properties||{};for(const e in l){const o=gc(r,null==(n=l[e])?void 0:n["x-refsStack"]);if(i.properties[e]){if(!y){const r=this.mergeAllOf({allOf:[i.properties[e],fc(dc({},l[e]),{"x-refsStack":o})],"x-refsStack":o},t+"/properties/"+e,o);i.properties[e]=r}}else i.properties[e]=fc(dc({},l[e]),{"x-refsStack":o})}}if(void 0!==c&&!y){const n="boolean"==typeof i.items?{}:Object.assign({},i.items),o="boolean"==typeof e.items?{}:Object.assign({},e.items);i.items=this.mergeAllOf({allOf:[n,o]},t+"/items",r)}void 0!==m&&(i.oneOf=m),void 0!==g&&(i.anyOf=g),void 0!==u&&(i.required=[...i.required||[],...u]),i=dc(fc(dc({},i),{title:i.title||p,description:i.description||d,readOnly:void 0!==i.readOnly?i.readOnly:f,writeOnly:void 0!==i.writeOnly?i.writeOnly:h,"x-circular-ref":i["x-circular-ref"]||y}),b)}return i}findDerived(e){const t={},r=this.spec.components&&this.spec.components.schemas||{};for(const n in r){const{resolved:i}=this.deref(r[n]);void 0!==i.allOf&&i.allOf.find(t=>void 0!==t.$ref&&e.indexOf(t.$ref)>-1)&&(t["#/components/schemas/"+n]=[i["x-discriminator-value"]||n])}return t}hoistOneOfs(e,t){if(void 0===e.allOf)return e;const r=e.allOf;for(let e=0;e0?[o]:[];return{oneOf:i.map(e=>({allOf:[...n,...a,e,...s],"x-refsStack":t}))}}}return e}}var bc=Object.defineProperty,vc=Object.defineProperties,xc=Object.getOwnPropertyDescriptor,wc=Object.getOwnPropertyDescriptors,kc=Object.getOwnPropertySymbols,Sc=Object.prototype.hasOwnProperty,Ec=Object.prototype.propertyIsEnumerable,Oc=(e,t,r)=>t in e?bc(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,_c=(e,t)=>{for(var r in t||(t={}))Sc.call(t,r)&&Oc(e,r,t[r]);if(kc)for(var r of kc(t))Ec.call(t,r)&&Oc(e,r,t[r]);return e},Pc=(e,t)=>vc(e,wc(t)),$c=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?xc(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&bc(t,r,o),o};const Ac=class e{constructor(e,t,r,n,i=!1,o=[]){this.options=n,this.refsStack=o,this.typePrefix="",this.isCircular=!1,this.activeOneOf=0,ir(this),this.pointer=t.$ref||r||"";const{resolved:s,refsStack:a}=e.deref(t,o,!0);this.refsStack=mc(a,this.pointer),this.rawSchema=s,this.schema=e.mergeAllOf(this.rawSchema,this.pointer,this.refsStack),this.init(e,i),n.showExtensions&&(this.extensions=va(this.schema,n.showExtensions))}activateOneOf(e){this.activeOneOf=e}hasType(e){return this.type===e||pi(this.type)&&this.type.includes(e)}init(t,r){var n,i,o,s,a,l,c,u;const p=this.schema;if(this.isCircular=!!p["x-circular-ref"],this.title=p.title||aa(this.pointer)&&Ls.baseName(this.pointer)||"",this.description=p.description||"",this.type=p.type||function(e){if(void 0!==e.type&&!pi(e.type))return e.type;const t=Object.keys(Js);for(const r of t){const t=Js[r];if(void 0!==e[r])return t}return"any"}(p),this.format=p.format,this.enum=p.enum||[],this["x-enumDescriptions"]=p["x-enumDescriptions"],this.example=p.example,this.examples=p.examples,this.deprecated=!!p.deprecated,this.pattern=p.pattern,this.externalDocs=p.externalDocs,this.constraints=ua(p),this.displayFormat=this.format,this.isPrimitive=Zs(p,this.type),this.default=p.default,this.readOnly=!!p.readOnly,this.writeOnly=!!p.writeOnly,this.const=p.const||"",this.contentEncoding=p.contentEncoding,this.contentMediaType=p.contentMediaType,this.minItems=p.minItems,this.maxItems=p.maxItems,(p.nullable||p["x-nullable"])&&(pi(this.type)&&!this.type.some(e=>null===e||"null"===e)?this.type=[...this.type,"null"]:pi(this.type)||null===this.type&&"null"===this.type||(this.type=[this.type,"null"])),this.displayType=pi(this.type)?this.type.map(e=>null===e?"null":e).join(" or "):this.type,!this.isCircular)if(p.if&&p.then||p.if&&p.else)this.initConditionalOperators(p,t);else if(r||void 0===Tc(p)){if(r&&pi(p.oneOf)&&p.oneOf.find(e=>e.$ref===this.pointer)&&delete p.oneOf,void 0!==p.oneOf)return this.initOneOf(p.oneOf,t),this.oneOfType="One of",void(void 0!==p.anyOf&&console.warn(`oneOf and anyOf are not supported on the same level. Skipping anyOf at ${this.pointer}`));if(void 0!==p.anyOf)return this.initOneOf(p.anyOf,t),void(this.oneOfType="Any of");if(this.hasType("object"))this.fields=jc(t,p,this.pointer,this.options,this.refsStack);else if(this.hasType("array")&&(pi(p.items)||pi(p.prefixItems)?this.fields=jc(t,p,this.pointer,this.options,this.refsStack):p.items&&(this.items=new e(t,p.items,this.pointer+"/items",this.options,!1,this.refsStack)),this.displayType=p.prefixItems||pi(p.items)?"items":((null==(n=this.items)?void 0:n.displayType)||this.displayType).split(" or ").map(e=>e.replace(/^(string|object|number|integer|array|boolean)s?( ?.*)/,"$1s$2")).join(" or "),this.displayFormat=(null==(i=this.items)?void 0:i.format)||"",this.typePrefix=(null==(o=this.items)?void 0:o.typePrefix)||""+hi("arrayOf"),this.title=this.title||(null==(s=this.items)?void 0:s.title)||"",this.isPrimitive=void 0!==(null==(a=this.items)?void 0:a.isPrimitive)?null==(l=this.items)?void 0:l.isPrimitive:this.isPrimitive,void 0===this.example&&void 0!==(null==(c=this.items)?void 0:c.example)&&(this.example=[this.items.example]),(null==(u=this.items)?void 0:u.isPrimitive)&&(this.enum=this.items.enum,this["x-enumDescriptions"]=this.items["x-enumDescriptions"]),pi(this.type))){const e=this.type.filter(e=>"array"!==e);e.length&&(this.displayType+=` or ${e.join(" or ")}`)}this.enum.length&&this.options.sortEnumValuesAlphabetically&&this.enum.sort()}else this.initDiscriminator(p,t)}initOneOf(t,r){if(this.oneOf=t.map((t,n)=>{const{resolved:i,refsStack:o}=r.deref(t,this.refsStack,!0),s=r.mergeAllOf(i,this.pointer+"/oneOf/"+n,o),a=aa(t.$ref)&&!s.title?Ls.baseName(t.$ref):`${s.title||""}${void 0!==s.const&&JSON.stringify(s.const)||""}`;return new e(r,Pc(_c({},s),{title:a,allOf:[Pc(_c({},this.schema),{oneOf:void 0,anyOf:void 0})],discriminator:i.allOf?void 0:s.discriminator}),t.$ref||this.pointer+"/oneOf/"+n,this.options,!1,o)}),this.options.simpleOneOfTypeLabel){const e=function(e){const t=new Set;return function e(r){for(const n of r.oneOf||[])n.oneOf?e(n):n.type&&t.add(n.type)}(e),Array.from(t.values())}(this);this.displayType=e.join(" or ")}else this.displayType=this.oneOf.map(e=>{let t=e.typePrefix+(e.title?`${e.title} (${e.displayType})`:e.displayType);return t.indexOf(" or ")>-1&&(t=`(${t})`),t}).join(" or ")}initDiscriminator(t,r){const n=Tc(t);this.discriminatorProp=n.propertyName;const i=r.findDerived([...this.schema["x-parentRefs"]||[],this.pointer]);if(t.oneOf)for(const e of t.oneOf){if(void 0===e.$ref)continue;const t=Ls.baseName(e.$ref);i[e.$ref]=t}const o=n.mapping||{};let s=n["x-explicitMappingOnly"]||!1;0===Object.keys(o).length&&(s=!1);const a={};for(const e in o){const t=o[e];pi(a[t])?a[t].push(e):a[t]=[e]}const l=_c(s?{}:_c({},i),a);let c=[];for(const e of Object.keys(l)){const t=l[e];if(pi(t))for(const r of t)c.push({$ref:e,name:r});else c.push({$ref:e,name:t})}const u=Object.keys(o);0!==u.length&&(c=c.sort((e,t)=>{const r=u.indexOf(e.name),n=u.indexOf(t.name);return r<0&&n<0?e.name.localeCompare(t.name):r<0?1:n<0?-1:r-n})),this.oneOf=c.map(({$ref:t,name:n})=>{const i=new e(r,{$ref:t},t,this.options,!0,this.refsStack.slice(0,-1));return i.title=n,i})}initConditionalOperators(t,r){const n=t,{if:i,else:o={},then:s={}}=n,a=((e,t)=>{var r={};for(var n in e)Sc.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&kc)for(var n of kc(e))t.indexOf(n)<0&&Ec.call(e,n)&&(r[n]=e[n]);return r})(n,["if","else","then"]),l=[{allOf:[a,s,i],title:i&&i["x-displayName"]||(null==i?void 0:i.title)||"case 1"},{allOf:[a,o],title:o&&o["x-displayName"]||(null==o?void 0:o.title)||"case 2"}];this.oneOf=l.map((t,n)=>new e(r,_c({},t),this.pointer+"/oneOf/"+n,this.options,!1,this.refsStack)),this.oneOfType="One of"}};$c([Ce],Ac.prototype,"activeOneOf",2),$c([Ct],Ac.prototype,"activateOneOf",1);let Cc=Ac;function jc(e,t,r,n,i){const o=t.properties||t.prefixItems||t.items||{},s=t.patternProperties||{},a=t.additionalProperties||t.unevaluatedProperties,l=t.prefixItems?t.items:t.additionalItems,c=t.default;let u=Object.keys(o||[]).map(s=>{let a=o[s];a||(console.warn(`Field "${s}" is invalid, skipping.\n Field must be an object but got ${typeof a} at "${r}"`),a={});const l=void 0!==t.required&&t.required.indexOf(s)>-1;return new zc(e,{name:t.properties?s:`[${s}]`,required:l,schema:Pc(_c({},a),{default:void 0===a.default&&c?c[s]:a.default})},r+"/properties/"+s,n,i)});return n.sortPropsAlphabetically&&(u=da(u,"name")),n.sortRequiredPropsFirst&&(u=pa(u,n.sortPropsAlphabetically?void 0:t.required)),u.push(...Object.keys(s).map(t=>{let o=s[t];return o||(console.warn(`Field "${t}" is invalid, skipping.\n Field must be an object but got ${typeof o} at "${r}"`),o={}),new zc(e,{name:t,required:!1,schema:o,kind:"patternProperties"},`${r}/patternProperties/${t}`,n,i)})),"object"!=typeof a&&!0!==a||u.push(new zc(e,{name:("object"==typeof a&&a["x-additionalPropertiesName"]||"property name").concat("*"),required:!1,schema:!0===a?{}:a,kind:"additionalProperties"},r+"/additionalProperties",n,i)),u.push(...function({parser:e,schema:t=!1,fieldsCount:r,$ref:n,options:i,refsStack:o}){return di(t)?t?[new zc(e,{name:`[${r}...]`,schema:{}},`${n}/additionalItems`,i,o)]:[]:pi(t)?[...t.map((t,s)=>new zc(e,{name:`[${r+s}]`,schema:t},`${n}/additionalItems`,i,o))]:si(t)?[new zc(e,{name:`[${r}...]`,schema:t},`${n}/additionalItems`,i,o)]:[]}({parser:e,schema:l,fieldsCount:u.length,$ref:r,options:n,refsStack:i})),u}function Tc(e){return e.discriminator||e["x-discriminator"]}const Nc={};class Ic{constructor(e,t,r,n){this.mime=r;const{resolved:i}=e.deref(t);this.value=i.value,this.summary=i.summary,this.description=i.description,i.externalValue&&(this.externalValueUrl=new URL(i.externalValue,e.specUrl).href),"application/x-www-form-urlencoded"===r&&this.value&&"object"==typeof this.value&&(this.value=function(e,t={}){if(pi(e))throw new Error("Payload must have fields: "+e.toString());return Object.keys(e).map(r=>{const n=e[r],{style:i="form",explode:o=!0}=t[r]||{};switch(i){case"form":return na(r,o,n);case"spaceDelimited":return ta(n,r,"%20");case"pipeDelimited":return ta(n,r,"|");case"deepObject":return ra(n,r);default:return console.warn("Incorrect or unsupported encoding style: "+i),""}}).join("&")}(this.value,n))}getExternalValue(e){return this.externalValueUrl?(this.externalValueUrl in Nc||(Nc[this.externalValueUrl]=fetch(this.externalValueUrl).then(t=>t.text().then(r=>{if(!t.ok)return Promise.reject(new Error(r));if(!ea(e))return r;try{return JSON.parse(r)}catch(e){return r}}))),Nc[this.externalValueUrl]):Promise.resolve(void 0)}}var Rc=Object.defineProperty,Lc=Object.getOwnPropertyDescriptor,Dc=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Lc(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Rc(t,r,o),o};const Mc={path:{style:"simple",explode:!1},query:{style:"form",explode:!0},header:{style:"simple",explode:!1},cookie:{style:"form",explode:!0}};class zc{constructor(e,t,r,n,i){var o,s,a,l,c;this.expanded=void 0,ir(this);const{resolved:u}=e.deref(t);this.kind=t.kind||"field",this.name=t.name||u.name,this.in=u.in,this.required=!!u.required;let p=u.schema,d="";if(!p&&u.in&&u.content&&(d=Object.keys(u.content)[0],p=u.content[d]&&u.content[d].schema),this.schema=new Cc(e,p||{},r,n,!1,i),this.description=void 0===u.description?this.schema.description||"":u.description,this.example=u.example||this.schema.example,void 0!==u.examples||void 0!==this.schema.examples){const t=u.examples||this.schema.examples;this.examples=pi(t)?t:ri(t,(t,r)=>new Ic(e,t,r,u.encoding))}d?this.serializationMime=d:u.style?this.style=u.style:this.in&&(this.style=null!=(s=null==(o=Mc[this.in])?void 0:o.style)?s:"form"),void 0===u.explode&&this.in?this.explode=null==(l=null==(a=Mc[this.in])?void 0:a.explode)||l:this.explode=!!u.explode,this.deprecated=void 0===u.deprecated?!!this.schema.deprecated:u.deprecated,n.showExtensions&&(this.extensions=va(u,n.showExtensions)),this.const=(null==(c=this.schema)?void 0:c.const)||(null==u?void 0:u.const)||""}toggle(){this.expanded=!this.expanded}collapse(){this.expanded=!1}expand(){this.expanded=!0}}Dc([Ce],zc.prototype,"expanded",2),Dc([Ct],zc.prototype,"toggle",1),Dc([Ct],zc.prototype,"collapse",1),Dc([Ct],zc.prototype,"expand",1);const Fc=Symbol("skip");function Bc(e){return e<10?"0"+e:e}function Uc(e,t){return t>e.length?e.repeat(Math.trunc(t/e.length)+1).substring(0,t):e}function qc(...e){const t=e=>e&&"object"==typeof e;return e.reduce((e,r)=>(Object.keys(r||{}).forEach(n=>{const i=e[n],o=r[n];t(i)&&t(o)?e[n]=qc(i,o):e[n]=o}),e),Array.isArray(e[e.length-1])?[]:{})}function Vc(e){return{value:"object"===e?{}:"array"===e?[]:void 0}}function Wc(e,t){t&&e.pop()}function Hc(e,t={},r={}){const{value:n}=e,{propertyName:i}=r,{name:o,prefix:s,namespace:a}=function(e){return{name:e?.xml?.name||"",prefix:e?.xml?.prefix||"",namespace:e?.xml?.namespace||null,attribute:e?.xml?.attribute??!1,wrapped:e?.xml?.wrapped??!1}}(t),l=function(e){const t=e?.xml;return t?.nodeType?t.nodeType:!0===t?.attribute?"attribute":!0===t?.wrapped&&"array"===e?.type?"element":e?.$ref||e?.$dynamicRef||"array"===e?.type||e?.oneOf||e?.anyOf||e?.allOf?"none":"element"}(t);let c=o||i?`${s?s+":":""}${o||i}`:null,u="object"==typeof n?Array.isArray(n)?[...n]:{...n}:n;switch(l){case"attribute":c&&(c=`$${c}`);break;case"text":c="#text";break;case"cdata":c="#cdata";break;case"none":"array"===t.type?(c=null,void 0!==t.example&&(c=t.items?.xml?.name||c)):c=null;break;default:"array"===t.type&&Array.isArray(u)&&(u={[c]:[...u]})}return a&&"text"!==l&&"cdata"!==l&&"none"!==l&&("object"==typeof u?u["$xmlns"+(s?":"+s:"")]=a:u={["$xmlns"+(s?":"+s:"")]:a,"#text":u}),{propertyName:c,value:u}}const Gc={multipleOf:"number",maximum:"number",exclusiveMaximum:"number",minimum:"number",exclusiveMinimum:"number",maxLength:"string",minLength:"string",pattern:"string",items:"array",maxItems:"array",minItems:"array",uniqueItems:"array",additionalItems:"array",maxProperties:"object",minProperties:"object",required:"object",additionalProperties:"object",properties:"object",patternProperties:"object",dependencies:"object"};function Yc(e){if(void 0!==e.type)return Array.isArray(e.type)?0===e.type.length?null:e.type[0]:e.type;const t=Object.keys(Gc);for(var r=0;rt.maxSampleDepth)return Wc(Qc,n),Vc(Yc(e));if(e.$ref){if(!r)throw new Error("Your schema contains $ref. You must provide full specification in the third parameter.");let i=decodeURIComponent(e.$ref);i.startsWith("#")&&(i=i.substring(1));const o=Is().get(r,i);let s;if(!0!==Kc[i]){Kc[i]=!0;const e=Zc(o,t,r,n);if("xml"===t.format){const t=i.split("/").pop(),r={...n,propertyName:n?.propertyName||t},{propertyName:a,value:l}=Hc(e,o,r);s={...e,value:{[a||"root"]:l}}}else s=e;Kc[i]=!1}else s=Vc(Yc(o));return Wc(Qc,n),s}if(void 0!==e.example)return Wc(Qc,n),{value:e.example,readOnly:e.readOnly,writeOnly:e.writeOnly,type:e.type};if(void 0!==e.allOf)return Wc(Qc,n),Jc(e)||function(e,t,r,n,i){let o=Zc(e,r,n);const s=[];for(let e of t){const{type:t,readOnly:a,writeOnly:l,value:c}=Zc({type:o.type,...e},r,n,{...i,isAllOfChild:!0});o.type&&t&&t!==o.type&&(console.warn("allOf: schemas with different types can't be merged"),o.type=t),o.type=o.type||t,o.readOnly=o.readOnly||a,o.writeOnly=o.writeOnly||l,null!=c&&s.push(c)}if("object"===o.type){o.value=qc(o.value||{},...s.filter(e=>"object"==typeof e));for(const e in o.value)o.value[e]===Fc&&delete o.value[e];return o}{"array"===o.type&&(r.quiet||console.warn('OpenAPI Sampler: found allOf with "array" type. Result may be incorrect'));const e=s[s.length-1];return o.value=null!=e?e:o.value,o}}({...e,allOf:void 0},e.allOf,t,r,n);if(e.oneOf&&e.oneOf.length)return e.anyOf&&(t.quiet||console.warn("oneOf and anyOf are not supported on the same level. Skipping anyOf")),Wc(Qc,n),s(e,Object.assign({readOnly:e.readOnly,writeOnly:e.writeOnly},e.oneOf[0]));if(e.anyOf&&e.anyOf.length)return Wc(Qc,n),s(e,Object.assign({readOnly:e.readOnly,writeOnly:e.writeOnly},e.anyOf[0]));if(e.if&&e.then){Wc(Qc,n);const{if:i,then:o,...s}=e;return Zc(qc(s,i,o),t,r,n)}let i=Xc(e),o=null;if(void 0===i){i=null,o=e.type,Array.isArray(o)&&e.type.length>0&&(o=e.type[0]),o||(o=Yc(e));let s=Lu[o];s&&(i=s(e,t,r,n))}return Wc(Qc,n),{value:i,readOnly:e.readOnly,writeOnly:e.writeOnly,type:o};function s(e,i){const o=Jc(e);if(void 0!==o)return o;const s=Zc({...e,oneOf:void 0,anyOf:void 0},t,r,n),a=Zc(i,t,r,n);if("object"==typeof s.value&&"object"==typeof a.value){const e=qc(s.value,a.value);return{...a,value:e}}return a}}function eu(e){let t=0;if("number"!==e.type||"float"!==e.format&&"double"!==e.format||(t=.1),"boolean"==typeof e.exclusiveMinimum||"boolean"==typeof e.exclusiveMaximum){if(e.maximum&&e.minimum)return t=e.exclusiveMinimum?Math.floor(e.minimum)+1:e.minimum,(e.exclusiveMaximum&&t>=e.maximum||!e.exclusiveMaximum&&t>e.maximum)&&(t=(e.maximum+e.minimum)/2),t;if(e.minimum)return e.exclusiveMinimum?Math.floor(e.minimum)+1:e.minimum;if(e.maximum)return e.exclusiveMaximum?e.maximum>0?0:Math.floor(e.maximum)-1:e.maximum>0?0:e.maximum}else{if(e.minimum)return e.minimum;e.exclusiveMinimum?(t=Math.floor(e.exclusiveMinimum)+1,t===e.exclusiveMaximum&&(t=(t+Math.floor(e.exclusiveMaximum)-1)/2)):e.exclusiveMaximum?t=Math.floor(e.exclusiveMaximum)-1:e.maximum&&(t=e.maximum)}return t}function tu(e,t){return e}function ru(e,t,r){let n=1;if(e)switch(e){case"?":n=0;break;case"*":n=tu(0);break;case"+":n=tu(1);break;default:throw new Error("Unknown quantifier symbol provided.")}else null!=t&&null!=r?n=tu(parseInt(t),parseInt(r)):null!=t&&null==r&&(n=parseInt(t));return n}function nu({min:e,max:t,omitTime:r,omitDate:n}){let i=function(e,t,r){var n=r?"":e.getUTCFullYear()+"-"+Bc(e.getUTCMonth()+1)+"-"+Bc(e.getUTCDate());return t||(n+="T"+Bc(e.getUTCHours())+":"+Bc(e.getUTCMinutes())+":"+Bc(e.getUTCSeconds())+"Z"),n}(new Date("2019-08-24T14:15:22.123Z"),r,n);return i.lengtht&&console.warn(`Using maxLength = ${t} is incorrect with format "date-time"`),i}function iu(e,t,r,n,i=!1){if(n&&i)return function(e){let t,r,n,i=!1;e instanceof RegExp&&(i=e.flags.includes("i"),e=e.toString(),e=e.match(/\/(.+?)\//)?.[1]??"");const o=/([.A-Za-z0-9])(?:\{(\d+)(?:\,(\d+)|)\}|(\?|\*|\+))(?![^[]*]|[^{]*})/;let s=(e=e.replace(/^(\^)?(.*?)(\$)?$/,"$2")).match(o);for(;null!=s;){const t=s[2],r=s[3];n=ru(s[4],t,r),e=e.slice(0,s.index)+s[1].repeat(n)+e.slice(s.index+s[0].length),s=e.match(o)}const a=/(\d-\d|\w-\w|\d|\w|[-!@#$&()`.+,/"])/,l=/\[(\^|)(-|)(.+?)\](?:\{(\d+)(?:\,(\d+)|)\}|(\?|\*|\+)|)/;for(s=e.match(l);null!=s;){const o="^"===s[1],c="-"===s[2],u=s[4],p=s[5],d=s[6],f=[];let h=s[3],m=h.match(a);for(c&&f.push(45);null!=m;){if(-1===m[0].indexOf("-"))i&&isNaN(Number(m[0]))?(f.push(m[0].toUpperCase().charCodeAt(0)),f.push(m[0].toLowerCase().charCodeAt(0))):f.push(m[0].charCodeAt(0));else{const e=m[0].split("-").map(e=>e.charCodeAt(0));if(t=e[0],r=e[1],t>r)throw new Error("Character range provided is out of order.");for(let e=t;e<=r;e++)if(i&&isNaN(Number(String.fromCharCode(e)))){const t=String.fromCharCode(e);f.push(t.toUpperCase().charCodeAt(0)),f.push(t.toLowerCase().charCodeAt(0))}else f.push(e)}h=h.substring(m[0].length),m=h.match(a)}if(n=ru(d,u,p),o){let e=-1;for(let t=48;t<=57;t++)e=f.indexOf(t),e>-1?f.splice(e,1):f.push(t);for(let t=65;t<=90;t++)e=f.indexOf(t),e>-1?f.splice(e,1):f.push(t);for(let t=97;t<=122;t++)e=f.indexOf(t),e>-1?f.splice(e,1):f.push(t)}const g=Array.from({length:n},()=>String.fromCharCode(f[tu(0,f.length)])).join("");s=(e=e.slice(0,s.index)+g+e.slice(s.index+s[0].length)).match(l)}const c=/(.)\{(\d+)\,(\d+)\}/;for(s=e.match(c);null!=s;){if(t=parseInt(s[2]),r=parseInt(s[3]),t>r)throw new Error("Numbers out of order in {} quantifier.");n=tu(t),e=e.slice(0,s.index)+s[1].repeat(n)+e.slice(s.index+s[0].length),s=e.match(c)}const u=/(.)\{(\d+)\}/;for(s=e.match(u);null!=s;)n=parseInt(s[2]),e=e.slice(0,s.index)+s[1].repeat(n)+e.slice(s.index+s[0].length),s=e.match(u);return e}(n);let o=Uc("string",e);return t&&o.length>t&&(o=o.substring(0,t)),o}const ou={email:function(){return"user@example.com"},"idn-email":function(){return"пошта@укр.нет"},password:function(e,t){let r="pa$$word";return e>r.length&&(r+="_",r+=Uc("qwerty!@#$%^123456",e-r.length).substring(0,e-r.length)),r},"date-time":function(e,t){return nu({min:e,max:t,omitTime:!1,omitDate:!1})},date:function(e,t){return nu({min:e,max:t,omitTime:!0,omitDate:!1})},time:function(e,t){return nu({min:e,max:t,omitTime:!1,omitDate:!0}).slice(1)},ipv4:function(){return"192.168.0.1"},ipv6:function(){return"2001:0db8:85a3:0000:0000:8a2e:0370:7334"},hostname:function(){return"example.com"},"idn-hostname":function(){return"приклад.укр"},iri:function(){return"http://example.com/entity/1"},"iri-reference":function(){return"/entity/1"},uri:function(){return"http://example.com"},"uri-reference":function(){return"../dictionary"},"uri-template":function(){return"http://example.com/{endpoint}"},uuid:function(e,t,r){return n=function(e){var t=0;if(0==e.length)return t;for(var r=0;r>>5)|0;return e=t^((r|=0)<<17|r>>>15),t=r+(n|=0)|0,r=n+i|0,((n=e+i|0)>>>0)/4294967296}}(n,n,n,n),"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{var t=16*i()%16|0;return("x"==e?t:3&t|8).toString(16)});var n,i},default:iu,"json-pointer":function(){return"/json/pointer"},"relative-json-pointer":function(){return"1/relative/json/pointer"},regex:function(){return"/regex/"}};class su{constructor(e,t={},r){this.pattern=e,this.separator=t.separator||".",this.segments=this._parse(e),this.data=r,this._hasDeepWildcard=this.segments.some(e=>"deep-wildcard"===e.type),this._hasAttributeCondition=this.segments.some(e=>void 0!==e.attrName),this._hasPositionSelector=this.segments.some(e=>void 0!==e.position)}_parse(e){const t=[];let r=0,n="";for(;r0?e[e.length-1].tag:void 0}getCurrentNamespace(){const e=this._matcher.path;return e.length>0?e[e.length-1].namespace:void 0}getAttrValue(e){const t=this._matcher.path;if(0!==t.length)return t[t.length-1].values?.[e]}hasAttr(e){const t=this._matcher.path;if(0===t.length)return!1;const r=t[t.length-1];return void 0!==r.values&&e in r.values}getPosition(){const e=this._matcher.path;return 0===e.length?-1:e[e.length-1].position??0}getCounter(){const e=this._matcher.path;return 0===e.length?-1:e[e.length-1].counter??0}getIndex(){return this.getPosition()}getDepth(){return this._matcher.path.length}toString(e,t=!0){return this._matcher.toString(e,t)}toArray(){return this._matcher.path.map(e=>e.tag)}matches(e){return this._matcher.matches(e)}matchesAny(e){return e.matchesAny(this._matcher)}}class lu{constructor(e={}){this.separator=e.separator||".",this.path=[],this.siblingStacks=[],this._pathStringCache=null,this._view=new au(this)}push(e,t=null,r=null){this._pathStringCache=null,this.path.length>0&&(this.path[this.path.length-1].values=void 0);const n=this.path.length;this.siblingStacks[n]||(this.siblingStacks[n]=new Map);const i=this.siblingStacks[n],o=r?`${r}:${e}`:e,s=i.get(o)||0;let a=0;for(const e of i.values())a+=e;i.set(o,s+1);const l={tag:e,position:a,counter:s};null!=r&&(l.namespace=r),null!=t&&(l.values=t),this.path.push(l)}pop(){if(0===this.path.length)return;this._pathStringCache=null;const e=this.path.pop();return this.siblingStacks.length>this.path.length+1&&(this.siblingStacks.length=this.path.length+1),e}updateCurrent(e){if(this.path.length>0){const t=this.path[this.path.length-1];null!=e&&(t.values=e)}}getCurrentTag(){return this.path.length>0?this.path[this.path.length-1].tag:void 0}getCurrentNamespace(){return this.path.length>0?this.path[this.path.length-1].namespace:void 0}getAttrValue(e){if(0!==this.path.length)return this.path[this.path.length-1].values?.[e]}hasAttr(e){if(0===this.path.length)return!1;const t=this.path[this.path.length-1];return void 0!==t.values&&e in t.values}getPosition(){return 0===this.path.length?-1:this.path[this.path.length-1].position??0}getCounter(){return 0===this.path.length?-1:this.path[this.path.length-1].counter??0}getIndex(){return this.getPosition()}getDepth(){return this.path.length}toString(e,t=!0){const r=e||this.separator;if(r===this.separator&&!0===t){if(null!==this._pathStringCache)return this._pathStringCache;const e=this.path.map(e=>e.namespace?`${e.namespace}:${e.tag}`:e.tag).join(r);return this._pathStringCache=e,e}return this.path.map(e=>t&&e.namespace?`${e.namespace}:${e.tag}`:e.tag).join(r)}toArray(){return this.path.map(e=>e.tag)}reset(){this._pathStringCache=null,this.path=[],this.siblingStacks=[]}matches(e){const t=e.segments;return 0!==t.length&&(e.hasDeepWildcard()?this._matchWithDeepWildcard(t):this._matchSimple(t))}_matchSimple(e){if(this.path.length!==e.length)return!1;for(let t=0;t=0&&t>=0;){const n=e[r];if("deep-wildcard"===n.type){if(r--,r<0)return!0;const n=e[r];let i=!1;for(let e=t;e>=0;e--)if(this._matchSegment(n,this.path[e],e===this.path.length-1)){t=e-1,r--,i=!0;break}if(!i)return!1}else{if(!this._matchSegment(n,this.path[t],t===this.path.length-1))return!1;t--,r--}}return r<0}_matchSegment(e,t,r){if("*"!==e.tag&&e.tag!==t.tag)return!1;if(void 0!==e.namespace&&"*"!==e.namespace&&e.namespace!==t.namespace)return!1;if(void 0!==e.attrName){if(!r)return!1;if(!t.values||!(e.attrName in t.values))return!1;if(void 0!==e.attrValue&&String(t.values[e.attrName])!==String(e.attrValue))return!1}if(void 0!==e.position){if(!r)return!1;const n=t.counter??0;if("first"===e.position&&0!==n)return!1;if("odd"===e.position&&n%2!=1)return!1;if("even"===e.position&&n%2!=0)return!1;if("nth"===e.position&&n!==e.positionValue)return!1}return!0}matchesAny(e){return e.matchesAny(this)}snapshot(){return{path:this.path.map(e=>({...e})),siblingStacks:this.siblingStacks.map(e=>new Map(e))}}restore(e){this._pathStringCache=null,this.path=e.path.map(e=>({...e})),this.siblingStacks=e.siblingStacks.map(e=>new Map(e))}readOnly(){return this._view}}function cu(e){return String(e).replace(/--/g,"- -").replace(/--/g,"- -").replace(/-$/,"- ")}function uu(e){return String(e).replace(/\]\]>/g,"]]]]>")}function pu(e){return String(e).replace(/"/g,""").replace(/'/g,"'")}const du=":A-Za-z_À-ÖØ-öø-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�",fu=":A-Za-z_À-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿",hu=fu+"\\-\\.\\d·̀-ͯ҇‿-⁀",mu=(e,t,r="")=>{const n=`[${e.replace(":","")}][${t.replace(":","")}]*`;return{name:new RegExp(`^[${e}][${t}]*$`,r),ncName:new RegExp(`^${n}$`,r),qName:new RegExp(`^${n}(?::${n})?$`,r),nmToken:new RegExp(`^[${t}]+$`,r),nmTokens:new RegExp(`^[${t}]+(?:\\s+[${t}]+)*$`,r)}},gu=mu(du,du+"\\-\\.\\d·̀-ͯ‿-⁀"),yu=mu(fu,hu,"u"),bu=(e,{xmlVersion:t="1.0"}={})=>((e="1.0")=>"1.1"===e?yu:gu)(t).qName.test(e);function vu(e,t,r,n,i){return r.sanitizeName?bu(e,{xmlVersion:i})?e:r.sanitizeName(e,{isAttribute:t,matcher:n.readOnly()}):e}function xu(e,t){let r="";t.format&&(r="\n");const n=[];if(t.stopNodes&&Array.isArray(t.stopNodes))for(let e=0;et.maxNestedTags)throw new Error("Maximum nested tags exceeded");if(!Array.isArray(e)){if(null!=e){let r=e.toString();return r=$u(r,t),r}return""}for(let l=0;l`,a=!1,n.pop();continue}if(p===t.commentPropName){s+=r+`\x3c!--${cu(c[u][0][t.textNodeName])}--\x3e`,a=!0,n.pop();continue}if("?"===p[0]){s+=("?xml"===p?"":r)+`<${p}${_u(c[":@"],t,f,n,o)}?>`,a=!0,n.pop();continue}let h=r;""!==h&&(h+=t.indentBy);const m=r+`<${p}${_u(c[":@"],t,f,n,o)}`;let g;g=f?Su(c[u],t):wu(c[u],t,h,n,i,o),-1!==t.unpairedTags.indexOf(p)?t.suppressUnpairedNode?s+=m+">":s+=m+"/>":g&&0!==g.length||!t.suppressEmptyNode?g&&g.endsWith(">")?s+=m+`>${g}${r}`:(s+=m+">",g&&""!==r&&(g.includes("/>")||g.includes("`):s+=m+"/>",a=!0,n.pop()}return s}function ku(e,t){if(!e||t.ignoreAttributes)return null;const r={};let n=!1;for(let i in e)Object.prototype.hasOwnProperty.call(e,i)&&(r[i.startsWith(t.attributeNamePrefix)?i.substr(t.attributeNamePrefix.length):i]=pu(e[i]),n=!0);return n?r:null}function Su(e,t){if(!Array.isArray(e))return null!=e?e.toString():"";let r="";for(let n=0;n${n}`:r+=`<${o}${e}/>`}}}return r}function Eu(e,t){let r="";if(e&&!t.ignoreAttributes)for(let n in e){if(!Object.prototype.hasOwnProperty.call(e,n))continue;let i=e[n];!0===i&&t.suppressBooleanAttributes?r+=` ${n.substr(t.attributeNamePrefix.length)}`:r+=` ${n.substr(t.attributeNamePrefix.length)}="${pu(i)}"`}return r}function Ou(e){const t=Object.keys(e);for(let r=0;r0&&t.processEntities)for(let r=0;r","g"),val:">"},{regex:new RegExp("<","g"),val:"<"},{regex:new RegExp("'","g"),val:"'"},{regex:new RegExp('"',"g"),val:"""}],processEntities:!0,stopNodes:[],oneListGroup:!1,maxNestedTags:100,jPath:!0,sanitizeName:!1};function Cu(e){if(this.options=Object.assign({},Au,e),this.options.stopNodes&&Array.isArray(this.options.stopNodes)&&(this.options.stopNodes=this.options.stopNodes.map(e=>"string"==typeof e&&e.startsWith("*.")?".."+e.substring(2):e)),this.stopNodeExpressions=[],this.options.stopNodes&&Array.isArray(this.options.stopNodes))for(let e=0;e{for(const r of t){if("string"==typeof r&&e===r)return!0;if(r instanceof RegExp&&r.test(e))return!0}}:()=>!1,this.attrPrefixLen=this.options.attributeNamePrefix.length,this.isAttribute=Iu),this.processTextOrObjNode=Tu,this.options.format?(this.indentate=Nu,this.tagEndChar=">\n",this.newLine="\n"):(this.indentate=function(){return""},this.tagEndChar=">",this.newLine="")}function ju(e,t,r,n,i){return r.sanitizeName?bu(e,{xmlVersion:i})?e:r.sanitizeName(e,{isAttribute:t,matcher:n.readOnly()}):e}function Tu(e,t,r,n,i){const o=this.extractAttributes(e);if(n.push(t,o),this.checkStopNode(n)){const i=this.buildRawContent(e),o=this.buildAttributesForStopNode(e);return n.pop(),this.buildObjectNode(i,t,o,r)}const s=this.j2x(e,r+1,n,i);return n.pop(),"?"===t[0]?this.buildTextValNode("",t,s.attrStr,r,n):void 0!==e[this.options.textNodeName]&&1===Object.keys(e).length?this.buildTextValNode(e[this.options.textNodeName],t,s.attrStr,r,n):this.buildObjectNode(s.val,t,s.attrStr,r)}function Nu(e){return this.options.indentBy.repeat(e)}function Iu(e){return!(!e.startsWith(this.options.attributeNamePrefix)||e===this.options.textNodeName)&&e.substr(this.attrPrefixLen)}Cu.prototype.build=function(e){if(this.options.preserveOrder)return xu(e,this.options);{Array.isArray(e)&&this.options.arrayNodeName&&this.options.arrayNodeName.length>1&&(e={[this.options.arrayNodeName]:e});const t=new lu,r=function(e,t){const r=e["?xml"];if(r&&"object"==typeof r){if(t.attributesGroupName&&r[t.attributesGroupName]){const e=r[t.attributesGroupName][t.attributeNamePrefix+"version"];if(e)return e}const e=r[t.attributeNamePrefix+"version"];if(e)return e}return"1.0"}(e,this.options);return this.j2x(e,0,t,r).val}},Cu.prototype.j2x=function(e,t,r,n){let i="",o="";if(this.options.maxNestedTags&&r.getDepth()>=this.options.maxNestedTags)throw new Error("Maximum nested tags exceeded");const s=this.options.jPath?r.toString():r,a=this.checkStopNode(r);for(let l in e){if(!Object.prototype.hasOwnProperty.call(e,l))continue;const c=l===this.options.textNodeName||l===this.options.cdataPropName||l===this.options.commentPropName||this.options.attributesGroupName&&l===this.options.attributesGroupName||this.isAttribute(l)||"?"===l[0]?l:ju(l,!1,this.options,r,n);if(void 0===e[l])this.isAttribute(l)&&(o+="");else if(null===e[l])this.isAttribute(l)||c===this.options.cdataPropName||c===this.options.commentPropName?o+="":"?"===c[0]?o+=this.indentate(t)+"<"+c+"?"+this.tagEndChar:o+=this.indentate(t)+"<"+c+"/"+this.tagEndChar;else if(e[l]instanceof Date)o+=this.buildTextValNode(e[l],c,"",t,r);else if("object"!=typeof e[l]){const u=this.isAttribute(l);if(u&&!this.ignoreAttributesFn(u,s)){const t=ju(u,!0,this.options,r,n);i+=this.buildAttrPairStr(t,""+e[l],a)}else if(!u)if(l===this.options.textNodeName){let t=this.options.tagValueProcessor(l,""+e[l]);o+=this.replaceEntitiesValue(t)}else{r.push(c);const n=this.checkStopNode(r);if(r.pop(),n){const r=""+e[l];o+=""===r?this.indentate(t)+"<"+c+this.closeTag(c)+this.tagEndChar:this.indentate(t)+"<"+c+">"+r+""+e+"${e}`;else if("object"==typeof e&&null!==e){const n=this.buildRawContent(e),i=this.buildAttributesForStopNode(e);t+=""===n?`<${r}${i}/>`:`<${r}${i}>${n}`}}else if("object"==typeof n&&null!==n){const e=this.buildRawContent(n),i=this.buildAttributesForStopNode(n);t+=""===e?`<${r}${i}/>`:`<${r}${i}>${e}`}else t+=`<${r}>${n}`}return t},Cu.prototype.buildAttributesForStopNode=function(e){if(!e||"object"!=typeof e)return"";let t="";if(this.options.attributesGroupName&&e[this.options.attributesGroupName]){const r=e[this.options.attributesGroupName];for(let e in r){if(!Object.prototype.hasOwnProperty.call(r,e))continue;const n=e.startsWith(this.options.attributeNamePrefix)?e.substring(this.options.attributeNamePrefix.length):e,i=r[e];!0===i&&this.options.suppressBooleanAttributes?t+=" "+n:t+=" "+n+'="'+i+'"'}}else for(let r in e){if(!Object.prototype.hasOwnProperty.call(e,r))continue;const n=this.isAttribute(r);if(n){const i=e[r];!0===i&&this.options.suppressBooleanAttributes?t+=" "+n:t+=" "+n+'="'+i+'"'}}return t},Cu.prototype.buildObjectNode=function(e,t,r,n){if(""===e)return"?"===t[0]?this.indentate(n)+"<"+t+r+"?"+this.tagEndChar:this.indentate(n)+"<"+t+r+this.closeTag(t)+this.tagEndChar;if("?"===t[0])return this.indentate(n)+"<"+t+r+"?"+this.tagEndChar;{let i=""+e+i}},Cu.prototype.closeTag=function(e){let t="";return-1!==this.options.unpairedTags.indexOf(e)?this.options.suppressUnpairedNode||(t="/"):t=this.options.suppressEmptyNode?"/":`>`+this.newLine}if(!1!==this.options.commentPropName&&t===this.options.commentPropName){const t=cu(e);return this.indentate(n)+`\x3c!--${t}--\x3e`+this.newLine}if("?"===t[0])return this.indentate(n)+"<"+t+r+"?"+this.tagEndChar;{let i=this.options.tagValueProcessor(t,e);return i=this.replaceEntitiesValue(i),""===i?this.indentate(n)+"<"+t+r+this.closeTag(t)+this.tagEndChar:this.indentate(n)+"<"+t+r+">"+i+"0&&this.options.processEntities)for(let t=0;t1)&&(e={[t?.xml?.name||"root"]:e}),new Ru({ignoreAttributes:!1,format:!0,attributeNamePrefix:"$",textNodeName:"#text",cdataPropName:"#cdata"}).build(e)}(i,e):i}function zu(e,t){Lu[e]=t}zu("array",function(e,t={},r,n){const i=n&&n.depth||1;let o=Math.min(null!=e.maxItems?e.maxItems:1/0,e.minItems||1);const s=e.prefixItems||e.items||e.contains;Array.isArray(s)&&(o=Math.max(o,s.length));let a=e=>Array.isArray(s)?s[e]||{}:s||{},l=[];if(!s)return l;for(let e=0;e({"#text":{...e}}))}}:{[r]:{...l,...t}}:{[r]:l})}return l}),zu("boolean",function(e){return!0}),zu("integer",eu),zu("number",eu),zu("object",function(e,t={},r,n){let i={};const o=n&&n.depth||1;if(e&&"object"==typeof e.properties){const s=Array.isArray(e.required)?e.required:[],a={};for(const e of s)a[e]=!0;Object.keys(e.properties).forEach(s=>{if(t.skipNonRequired&&!a.hasOwnProperty(s))return;const l=Zc(e.properties[s],t,r,{propertyName:s,depth:o+1});if(t.skipReadOnly&&l.readOnly)n?.isAllOfChild&&(i[s]=Fc);else if(t.skipWriteOnly&&l.writeOnly)n?.isAllOfChild&&(i[s]=Fc);else if("xml"===t?.format){const{propertyName:t,value:r}=Hc(l,e.properties[s],{propertyName:s});t?i[t]=r:null!==r&&"object"==typeof r&&(i={...i,...r})}else i[s]=l.value})}if(e&&"object"==typeof e.additionalProperties){const n=e.additionalProperties["x-additionalPropertiesName"]||"property";i[`${String(n)}1`]=Zc(e.additionalProperties,t,r,{depth:o+1}).value,i[`${String(n)}2`]=Zc(e.additionalProperties,t,r,{depth:o+1}).value}if(e&&"object"==typeof e.properties&&void 0!==e.maxProperties&&Object.keys(i).length>e.maxProperties){const t={};let r=0;(Array.isArray(e.required)?e.required:[]).forEach(e=>{void 0!==i[e]&&(t[e]=i[e],r++)}),Object.keys(i).forEach(n=>{rnew Ic(e,r,t,n.encoding)):void 0!==n.example?this.examples={default:new Ic(e,{value:e.deref(n.example).resolved},t,n.encoding)}:ea(t)&&this.generateExample(e,n)}generateExample(e,t){const r={skipReadOnly:this.isRequestType,skipWriteOnly:!this.isRequestType,skipNonRequired:this.isRequestType&&this.onlyRequiredInSamples,maxSampleDepth:this.generatedSamplesMaxDepth};if(this.schema&&this.schema.oneOf){this.examples={};for(const n of this.schema.oneOf){const i=Mu(n.rawSchema,r,e.spec);this.schema.discriminatorProp&&"object"==typeof i&&i&&(i[this.schema.discriminatorProp]=n.title),this.examples[n.title]=new Ic(e,{value:i},this.name,t.encoding)}}else this.schema&&(this.examples={default:new Ic(e,{value:Mu(t.schema,r,e.spec)},this.name,t.encoding)})}}var Bu=Object.defineProperty,Uu=Object.getOwnPropertyDescriptor,qu=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Uu(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Bu(t,r,o),o};class Vu{constructor(e,t,r,n){this.isRequestType=r,this.activeMimeIdx=0,ir(this),n.unstable_ignoreMimeParameters&&(t=function(e){const t={};return Object.keys(e).forEach(r=>{const n=e[r],i=r.split(";")[0].trim();t[i]?t[i]=Hs(Hs({},t[i]),n):t[i]=n}),t}(t)),this.mediaTypes=Object.keys(t).map(i=>{const o=t[i];return new Fu(e,i,r,o,n)})}activate(e){this.activeMimeIdx=e}get active(){return this.mediaTypes[this.activeMimeIdx]}get hasSample(){return this.mediaTypes.filter(e=>!!e.examples).length>0}}qu([Ce],Vu.prototype,"activeMimeIdx",2),qu([Ct],Vu.prototype,"activate",1),qu([Ie],Vu.prototype,"active",1);class Wu{constructor({parser:e,infoOrRef:t,options:r,isEvent:n}){const i=!n,{resolved:o}=e.deref(t);this.description=o.description||"",this.required=o.required;const s=function(e){let t=e.content;const r=e["x-examples"],n=e["x-example"];if(r){t=Hs({},t);for(const e of Object.keys(r)){const n=r[e];t[e]=Gs(Hs({},t[e]),{examples:n})}}else if(n){t=Hs({},t);for(const e of Object.keys(n)){const r=n[e];t[e]=Gs(Hs({},t[e]),{example:r})}}return t}(o);void 0!==s&&(this.content=new Vu(e,s,i,r))}}var Hu=Object.defineProperty,Gu=Object.defineProperties,Yu=Object.getOwnPropertyDescriptor,Ku=Object.getOwnPropertyDescriptors,Qu=Object.getOwnPropertySymbols,Xu=Object.prototype.hasOwnProperty,Ju=Object.prototype.propertyIsEnumerable,Zu=(e,t,r)=>t in e?Hu(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,ep=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Yu(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Hu(t,r,o),o};class tp{constructor({parser:e,code:t,defaultAsError:r,infoOrRef:n,options:i,isEvent:o}){this.expanded=!1,this.headers=[],ir(this),this.expanded="all"===i.expandResponses||i.expandResponses[t];const{resolved:s}=e.deref(n);this.code=t,void 0!==s.content&&(this.content=new Vu(e,s.content,o,i)),void 0!==s["x-summary"]?(this.summary=s["x-summary"],this.description=s.description||""):(this.summary=s.description||"",this.description=""),this.type=Ks(t,r);const a=s.headers;void 0!==a&&(this.headers=Object.keys(a).map(t=>{const r=a[t];return new zc(e,((e,t)=>Gu(e,Ku(t)))(((e,t)=>{for(var r in t||(t={}))Xu.call(t,r)&&Zu(e,r,t[r]);if(Qu)for(var r of Qu(t))Ju.call(t,r)&&Zu(e,r,t[r]);return e})({},r),{name:t}),"",i)})),i.showExtensions&&(this.extensions=va(s,i.showExtensions))}toggle(){this.expanded=!this.expanded}}ep([Ce],tp.prototype,"expanded",2),ep([Ct],tp.prototype,"toggle",1);var rp=Object.defineProperty,np=Object.getOwnPropertyDescriptor,ip=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?np(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&rp(t,r,o),o};function op(e){return"payload"===e.lang&&e.requestBodyContent}let sp=!1;class ap{constructor(e,t,r,n,i=!1){var o,s;this.parser=e,this.operationSpec=t,this.options=n,this.type="operation",this.items=[],this.ready=!0,this.active=!1,this.expanded=!1,ir(this),this.pointer=t.pointer,this.description=t.description,this.parent=r,this.externalDocs=t.externalDocs,this.deprecated=!!t.deprecated,this.httpVerb=t.httpVerb,this.deprecated=!!t.deprecated,this.operationId=t.operationId,this.path=t.pathName,this.isCallback=i,this.isWebhook=t.isWebhook,this.isEvent=this.isCallback||this.isWebhook,this.name=(s=t).summary||s.operationId||s.description&&s.description.substring(0,50)||s.pathName||"",this.sidebarLabel=n.sideNavStyle===mi.IdOnly?this.operationId||this.path:n.sideNavStyle===mi.PathOnly?this.path:this.name,this.badges=(null==(o=t["x-badges"])?void 0:o.map(({name:e,color:t,position:r})=>({name:e,color:t,position:r||"after"})))||[],this.isCallback?(this.security=(t.security||[]).map(t=>new Hl(t,e)),this.servers=fa("",t.servers||t.pathServers||[])):(this.operationHash=t.operationId&&"operation/"+t.operationId,this.id=void 0!==t.operationId?(r?r.id+"/":"")+this.operationHash:void 0!==r?r.id+this.pointer:this.pointer,this.security=(t.security||e.spec.security||[]).map(t=>new Hl(t,e)),this.servers=fa(e.specUrl,t.servers||t.pathServers||e.spec.servers||[])),n.showExtensions&&(this.extensions=va(t,n.showExtensions))}activate(){this.active=!0}deactivate(){this.active=!1}toggle(){this.expanded=!this.expanded}expand(){this.parent&&this.parent.expand()}collapse(){}get requestBody(){return this.operationSpec.requestBody&&new Wu({parser:this.parser,infoOrRef:this.operationSpec.requestBody,options:this.options,isEvent:this.isEvent})}get codeSamples(){const{payloadSampleIdx:e,hideRequestPayloadSample:t}=this.options;let r=this.operationSpec["x-codeSamples"]||this.operationSpec["x-code-samples"]||[];this.operationSpec["x-code-samples"]&&!sp&&(sp=!0,console.warn('"x-code-samples" is deprecated. Use "x-codeSamples" instead'));const n=this.requestBody&&this.requestBody.content;if(n&&n.hasSample&&!t){const t=Math.min(r.length,e);r=[...r.slice(0,t),{lang:"payload",label:"Payload",source:"",requestBodyContent:n},...r.slice(t)]}return r}get parameters(){const e=function(e,t=[],r=[]){const n={};return r.forEach(t=>{({resolved:t}=e.deref(t)),n[t.name+"_"+t.in]=!0}),(t=t.filter(t=>(({resolved:t}=e.deref(t)),!n[t.name+"_"+t.in]))).concat(r)}(this.parser,this.operationSpec.pathParameters,this.operationSpec.parameters).map(e=>new zc(this.parser,e,this.pointer,this.options));return this.options.sortPropsAlphabetically?da(e,"name"):this.options.sortRequiredPropsFirst?pa(e):e}get responses(){let e=!1;return Object.keys(this.operationSpec.responses||[]).filter(t=>{return"default"===t||("success"===Ks(t)&&(e=!0),"default"===(r=t)||ii(r)||Ys(r));var r}).map(t=>new tp({parser:this.parser,code:t,defaultAsError:e,infoOrRef:this.operationSpec.responses[t],options:this.options,isEvent:this.isEvent}))}get callbacks(){return Object.keys(this.operationSpec.callbacks||[]).map(e=>new ic(this.parser,e,this.operationSpec.callbacks[e],this.pointer,this.options))}}ip([Ce],ap.prototype,"ready",2),ip([Ce],ap.prototype,"active",2),ip([Ce],ap.prototype,"expanded",2),ip([Ct],ap.prototype,"activate",1),ip([Ct],ap.prototype,"deactivate",1),ip([Ct],ap.prototype,"toggle",1),ip([Na],ap.prototype,"requestBody",1),ip([Na],ap.prototype,"codeSamples",1),ip([Na],ap.prototype,"parameters",1),ip([Na],ap.prototype,"responses",1),ip([Na],ap.prototype,"callbacks",1);const lp=gs.div` + width: calc(100% - ${e=>e.theme.rightPanel.width}); + padding: 0 ${e=>e.theme.spacing.sectionHorizontal}px; + + ${({$compact:e,theme:t})=>ms.lessThan("medium",!0)` + width: 100%; + padding: ${`${e?0:t.spacing.sectionVertical}px ${t.spacing.sectionHorizontal}px`}; + `}; +`,cp=gs.div.attrs(e=>({[eh]:e.id}))` + padding: ${e=>e.theme.spacing.sectionVertical}px 0; + + &:last-child { + min-height: calc(100vh + 1px); + } + + & > &:last-child { + min-height: initial; + } + + ${ms.lessThan("medium",!0)` + padding: 0; + `} + ${({$underlined:e})=>e?"\n position: relative;\n\n &:not(:last-of-type):after {\n position: absolute;\n bottom: 0;\n width: 100%;\n display: block;\n content: '';\n border-bottom: 1px solid rgba(0, 0, 0, 0.2);\n }\n ":""} +`,up=gs.div` + width: ${e=>e.theme.rightPanel.width}; + color: ${({theme:e})=>e.rightPanel.textColor}; + background-color: ${e=>e.theme.rightPanel.backgroundColor}; + padding: 0 ${e=>e.theme.spacing.sectionHorizontal}px; + + ${ms.lessThan("medium",!0)` + width: 100%; + padding: ${e=>`${e.theme.spacing.sectionVertical}px ${e.theme.spacing.sectionHorizontal}px`}; + `}; +`,pp=gs(up)` + background-color: ${e=>e.theme.rightPanel.backgroundColor}; +`,dp=gs.div` + display: flex; + width: 100%; + padding: 0; + + ${ms.lessThan("medium",!0)` + flex-direction: column; + `}; +`,fp={1:"1.85714em",2:"1.57143em",3:"1.27em"},hp=e=>ps` + font-family: ${({theme:e})=>e.typography.headings.fontFamily}; + font-weight: ${({theme:e})=>e.typography.headings.fontWeight}; + font-size: ${fp[e]}; + line-height: ${({theme:e})=>e.typography.headings.lineHeight}; +`,mp=gs.h1` + ${hp(1)}; + color: ${({theme:e})=>e.colors.text.primary}; + + ${ys("H1")}; +`,gp=gs.h2` + ${hp(2)}; + color: ${({theme:e})=>e.colors.text.primary}; + margin: 0 0 20px; + + ${ys("H2")}; +`,yp=gs.h2` + ${hp(3)}; + color: ${({theme:e})=>e.colors.text.primary}; + + ${ys("H3")}; +`,bp=gs.h3` + color: ${({theme:e})=>e.rightPanel.textColor}; + + ${ys("RightPanelHeader")}; +`,vp=gs.h5` + border-bottom: 1px solid rgba(38, 50, 56, 0.3); + margin: 1em 0 1em 0; + color: rgba(38, 50, 56, 0.5); + font-weight: normal; + text-transform: uppercase; + font-size: 0.929em; + line-height: 20px; + + ${ys("UnderlinedHeader")}; +`,xp=(0,r.createContext)(void 0),{Provider:wp,Consumer:kp}=xp;function Sp(e){const{spec:t,specUrl:i,options:o,onLoaded:s,children:a}=e,[l,c]=r.useState(null),[u,p]=r.useState(null);if(u)throw u;r.useEffect(()=>{!function(){return e=this,r=function*(){if(t||i){c(null);try{const e=yield function(e){return t=this,r=function*(){const t=new As.Config({}),r={config:t,base:Qn?window.location.href:process.cwd()};Qn&&(t.resolve.http.customFetch=n.g.fetch),"object"==typeof e&&null!==e?r.doc={source:{absoluteRef:""},parsed:e}:r.ref=e;const{bundle:{parsed:i}}=yield(0,$s.l2)(r);return void 0!==i.swagger?(o=i,console.warn("[ReDoc Compatibility mode]: Converting OpenAPI 2.0 to OpenAPI 3.0"),new Promise((e,t)=>(0,Cs.convertObj)(o,{patch:!0,warnOnly:!0,text:"{}",anchors:!0},(r,n)=>{if(r)return t(r);e(n&&n.openapi)}))):i;var o},new Promise((e,n)=>{var i=e=>{try{s(r.next(e))}catch(e){n(e)}},o=e=>{try{s(r.throw(e))}catch(e){n(e)}},s=t=>t.done?e(t.value):Promise.resolve(t.value).then(i,o);s((r=r.apply(t,null)).next())});var t,r}(t||i);c(e)}catch(e){throw s&&s(e),p(e),e}}},new Promise((t,n)=>{var i=e=>{try{s(r.next(e))}catch(e){n(e)}},o=e=>{try{s(r.throw(e))}catch(e){n(e)}},s=e=>e.done?t(e.value):Promise.resolve(e.value).then(i,o);s((r=r.apply(e,null)).next())});var e,r}()},[t,i]);const d=r.useMemo(()=>{if(!l)return null;try{return new Lb(l,i,o)}catch(e){throw s&&s(e),e}},[l,i,o]);return r.useEffect(()=>{d&&s&&s()},[d,s]),a({loading:!d,store:d})}const Ep=e=>ps` + ${e} { + cursor: pointer; + margin-left: -20px; + padding: 0; + line-height: 1; + width: 20px; + display: inline-block; + outline: 0; + } + ${e}:before { + content: ''; + width: 15px; + height: 15px; + background-size: contain; + background-image: url('data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZlcnNpb249IjEuMSIgeD0iMCIgeT0iMCIgd2lkdGg9IjUxMiIgaGVpZ2h0PSI1MTIiIHZpZXdCb3g9IjAgMCA1MTIgNTEyIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCA1MTIgNTEyIiB4bWw6c3BhY2U9InByZXNlcnZlIj48cGF0aCBmaWxsPSIjMDEwMTAxIiBkPSJNNDU5LjcgMjMzLjRsLTkwLjUgOTAuNWMtNTAgNTAtMTMxIDUwLTE4MSAwIC03LjktNy44LTE0LTE2LjctMTkuNC0yNS44bDQyLjEtNDIuMWMyLTIgNC41LTMuMiA2LjgtNC41IDIuOSA5LjkgOCAxOS4zIDE1LjggMjcuMiAyNSAyNSA2NS42IDI0LjkgOTAuNSAwbDkwLjUtOTAuNWMyNS0yNSAyNS02NS42IDAtOTAuNSAtMjQuOS0yNS02NS41LTI1LTkwLjUgMGwtMzIuMiAzMi4yYy0yNi4xLTEwLjItNTQuMi0xMi45LTgxLjYtOC45bDY4LjYtNjguNmM1MC01MCAxMzEtNTAgMTgxIDBDNTA5LjYgMTAyLjMgNTA5LjYgMTgzLjQgNDU5LjcgMjMzLjR6TTIyMC4zIDM4Mi4ybC0zMi4yIDMyLjJjLTI1IDI0LjktNjUuNiAyNC45LTkwLjUgMCAtMjUtMjUtMjUtNjUuNiAwLTkwLjVsOTAuNS05MC41YzI1LTI1IDY1LjUtMjUgOTAuNSAwIDcuOCA3LjggMTIuOSAxNy4yIDE1LjggMjcuMSAyLjQtMS40IDQuOC0yLjUgNi44LTQuNWw0Mi4xLTQyYy01LjQtOS4yLTExLjYtMTgtMTkuNC0yNS44IC01MC01MC0xMzEtNTAtMTgxIDBsLTkwLjUgOTAuNWMtNTAgNTAtNTAgMTMxIDAgMTgxIDUwIDUwIDEzMSA1MCAxODEgMGw2OC42LTY4LjZDMjc0LjYgMzk1LjEgMjQ2LjQgMzkyLjMgMjIwLjMgMzgyLjJ6Ii8+PC9zdmc+Cg=='); + opacity: 0.5; + visibility: hidden; + display: inline-block; + vertical-align: middle; + } + + h1:hover > ${e}::before, h2:hover > ${e}::before, ${e}:hover::before { + visibility: visible; + } +`,Op=gs(function(e){const t=r.useContext(xp),n=r.useCallback(r=>{t&&function(e,t,r){t.defaultPrevented||0!==t.button||(e=>!!(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey))(t)||(t.preventDefault(),e.replace(encodeURI(r)))}(t.menu.history,r,e.to)},[t,e.to]);return t?r.createElement("a",{className:e.className,href:t.menu.history.linkForId(e.to),onClick:n,"aria-label":e.to},e.children):null})` + ${Ep("&")}; +`;function _p(e){return r.createElement(Op,{to:e.to})}const Pp={left:"90deg",right:"-90deg",up:"-180deg",down:"0"},$p=gs(e=>r.createElement("svg",{className:e.className,style:e.style,version:"1.1",viewBox:"0 0 24 24",x:"0",xmlns:"http://www.w3.org/2000/svg",y:"0","aria-hidden":"true"},r.createElement("polygon",{points:"17.3 8.3 12 13.6 6.7 8.3 5.3 9.7 12 16.4 18.7 9.7 "})))` + height: ${e=>e.size||"18px"}; + width: ${e=>e.size||"18px"}; + min-width: ${e=>e.size||"18px"}; + vertical-align: middle; + float: ${e=>e.float||""}; + transition: transform 0.2s ease-out; + transform: rotateZ(${e=>Pp[e.direction||"down"]}); + + polygon { + fill: ${({color:e,theme:t})=>e&&t.colors.responses[e]&&t.colors.responses[e].color||e}; + } +`,Ap=gs.span` + display: inline-block; + padding: 2px 8px; + margin: 0; + background-color: ${e=>e.color||e.theme.colors[e.type].main}; + color: ${e=>e.theme.colors[e.type].contrastText}; + font-size: ${e=>e.theme.typography.code.fontSize}; + vertical-align: middle; + line-height: 1.6; + border-radius: 4px; + font-weight: ${({theme:e})=>e.typography.fontWeightBold}; + font-size: 12px; + + span[type] { + margin-left: 4px; + } +`,Cp=ps` + text-decoration: line-through; + color: #707070; +`,jp=gs.caption` + text-align: right; + font-size: 0.9em; + font-weight: normal; + color: ${e=>e.theme.colors.text.secondary}; +`,Tp=gs.td` + border-left: 1px solid ${e=>e.theme.schema.linesColor}; + box-sizing: border-box; + position: relative; + padding: 10px 10px 10px 0; + + ${ms.lessThan("small")` + display: block; + overflow: hidden; + `} + + tr:first-of-type > &, + tr.last > & { + border-left-width: 0; + background-position: top left; + background-repeat: no-repeat; + background-size: 1px 100%; + } + + tr:first-of-type > & { + background-image: linear-gradient( + to bottom, + transparent 0%, + transparent 22px, + ${e=>e.theme.schema.linesColor} 22px, + ${e=>e.theme.schema.linesColor} 100% + ); + } + + tr.last > & { + background-image: linear-gradient( + to bottom, + ${e=>e.theme.schema.linesColor} 0%, + ${e=>e.theme.schema.linesColor} 22px, + transparent 22px, + transparent 100% + ); + } + + tr.last + tr > & { + border-left-color: transparent; + } + + tr.last:first-child > & { + background: none; + border-left-color: transparent; + } +`,Np=gs(Tp)` + padding: 0; +`,Ip=gs(Tp)` + vertical-align: top; + line-height: 20px; + white-space: nowrap; + font-size: 13px; + font-family: ${e=>e.theme.typography.code.fontFamily}; + + &.deprecated { + ${Cp}; + } + + ${({kind:e})=>"patternProperties"===e&&ps` + > span.property-name { + display: inline-table; + white-space: break-spaces; + margin-right: 20px; + + ::before, + ::after { + content: '/'; + filter: opacity(0.2); + } + } + `} + + ${({kind:e=""})=>["field","additionalProperties","patternProperties"].includes(e)?"":"font-style: italic"}; + + ${ys("PropertyNameCell")}; +`,Rp=gs.td` + border-bottom: 1px solid #9fb4be; + padding: 10px 0; + width: ${e=>e.theme.schema.defaultDetailsWidth}; + box-sizing: border-box; + + tr.expanded & { + border-bottom: none; + } + + ${ms.lessThan("small")` + padding: 0 20px; + border-bottom: none; + border-left: 1px solid ${e=>e.theme.schema.linesColor}; + + tr.last > & { + border-left: none; + } + `} + + ${ys("PropertyDetailsCell")}; +`,Lp=gs.span` + color: ${e=>e.theme.schema.linesColor}; + font-family: ${e=>e.theme.typography.code.fontFamily}; + margin-right: 10px; + + &::before { + content: ''; + display: inline-block; + vertical-align: middle; + width: 10px; + height: 1px; + background: ${e=>e.theme.schema.linesColor}; + } + + &::after { + content: ''; + display: inline-block; + vertical-align: middle; + width: 1px; + background: ${e=>e.theme.schema.linesColor}; + height: 7px; + } +`,Dp=gs.div` + padding: ${({theme:e})=>e.schema.nestingSpacing}; +`,Mp=gs.table` + border-collapse: separate; + border-radius: 3px; + font-size: ${e=>e.theme.typography.fontSize}; + + border-spacing: 0; + width: 100%; + + > tr { + vertical-align: middle; + } + + ${ms.lessThan("small")` + display: block; + > tr, > tbody > tr { + display: block; + } + `} + + ${ms.lessThan("small",!1," and (-ms-high-contrast:none)")` + td { + float: left; + width: 100%; + } + `} + + & + ${Dp}, + & + ${Dp} + ${Dp} + ${Dp}, + & + ${Dp} + ${Dp} + ${Dp} + ${Dp} + ${Dp} { + margin: ${({theme:e})=>e.schema.nestingSpacing}; + margin-right: 0; + background: ${({theme:e})=>e.schema.nestedBackground}; + } + + & + ${Dp} + ${Dp}, + & + ${Dp} + ${Dp} + ${Dp} + ${Dp}, + & + ${Dp} + ${Dp} + ${Dp} + ${Dp} + ${Dp} + ${Dp} { + background: #ffffff; + } +`,zp=gs.div` + margin: 0 0 3px 0; + display: inline-block; +`,Fp=gs.span` + font-size: 0.9em; + margin-right: 10px; + color: ${e=>e.theme.colors.primary.main}; + font-family: ${e=>e.theme.typography.headings.fontFamily}; +} +`,Bp=gs.button` + display: inline-block; + margin-right: 10px; + margin-bottom: 5px; + font-size: 0.8em; + cursor: pointer; + border: 1px solid ${e=>e.theme.colors.primary.main}; + padding: 2px 10px; + line-height: 1.5em; + outline: none; + &:focus { + box-shadow: 0 0 0 1px ${e=>e.theme.colors.primary.main}; + } + + ${({$deprecated:e})=>e&&Cp||""}; + + ${e=>e.$active?`\n color: white;\n background-color: ${e.theme.colors.primary.main};\n &:focus {\n box-shadow: none;\n background-color: ${Dn(.15,e.theme.colors.primary.main)};\n }\n `:`\n color: ${e.theme.colors.primary.main};\n background-color: white;\n `} +`,Up=gs.div` + font-size: 0.9em; + font-family: ${e=>e.theme.typography.code.fontFamily}; + &::after { + content: ' ['; + } +`,qp=gs.div` + font-size: 0.9em; + font-family: ${e=>e.theme.typography.code.fontFamily}; + &::after { + content: ']'; + } +`;function Vp(e){return t=>!!t.type&&t.type.tabsRole===e}const Wp=Vp("Tab"),Hp=Vp("TabList"),Gp=Vp("TabPanel");function Yp(e,t){return r.Children.map(e,e=>null===e?null:function(e){return Wp(e)||Hp(e)||Gp(e)}(e)?t(e):e.props&&e.props.children&&"object"==typeof e.props.children?(0,r.cloneElement)(e,{...e.props,children:Yp(e.props.children,t)}):e)}function Kp(e,t){return r.Children.forEach(e,e=>{null!==e&&(Wp(e)||Gp(e)?t(e):e.props&&e.props.children&&"object"==typeof e.props.children&&(Hp(e)&&t(e),Kp(e.props.children,t)))})}function Qp(e){var t,r,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var i=e.length;for(t=0;t{Wp(e)&&t++}),t}function Zp(e){return e&&"getAttribute"in e}function ed(e){return Zp(e)&&e.getAttribute("data-rttab")}function td(e){return Zp(e)&&"true"===e.getAttribute("aria-disabled")}let rd;const nd={className:"react-tabs",focus:!1},id=e=>{let t=(0,r.useRef)([]),n=(0,r.useRef)([]);const i=(0,r.useRef)();function o(t,r){if(t<0||t>=l())return;const{onSelect:n,selectedIndex:i}=e;n(t,i,r)}function s(e){const t=l();for(let r=e+1;re;)if(!td(c(t)))return t;return e}function l(){const{children:t}=e;return Jp(t)}function c(e){return t.current[`tabs-${e}`]}function u(e){let t=e.target;do{if(p(t)){if(td(t))return;return void o([].slice.call(t.parentNode.children).filter(ed).indexOf(t),e)}}while(null!=(t=t.parentNode))}function p(e){if(!ed(e))return!1;let t=e.parentElement;do{if(t===i.current)return!0;if(t.getAttribute("data-rttabs"))break;t=t.parentElement}while(t);return!1}const{children:d,className:f,disabledTabClassName:h,domRef:m,focus:g,forceRenderTabPanel:y,onSelect:b,selectedIndex:v,selectedTabClassName:x,selectedTabPanelClassName:w,environment:k,disableUpDownKeys:S,disableLeftRightKeys:E,...O}={...nd,...e};return r.createElement("div",Object.assign({},O,{className:Xp(f),onClick:u,onKeyDown:function(t){const{direction:r,disableUpDownKeys:n,disableLeftRightKeys:i}=e;if(p(t.target)){let{selectedIndex:p}=e,d=!1,f=!1;"Space"!==t.code&&32!==t.keyCode&&"Enter"!==t.code&&13!==t.keyCode||(d=!0,f=!1,u(t)),(i||37!==t.keyCode&&"ArrowLeft"!==t.code)&&(n||38!==t.keyCode&&"ArrowUp"!==t.code)?(i||39!==t.keyCode&&"ArrowRight"!==t.code)&&(n||40!==t.keyCode&&"ArrowDown"!==t.code)?35===t.keyCode||"End"===t.code?(p=function(){let e=l();for(;e--;)if(!td(c(e)))return e;return null}(),d=!0,f=!0):36!==t.keyCode&&"Home"!==t.code||(p=function(){const e=l();for(let t=0;t{i.current=e,m&&m(e)},"data-rttabs":!0}),function(){let i=0;const{children:o,disabledTabClassName:s,focus:a,forceRenderTabPanel:u,selectedIndex:p,selectedTabClassName:d,selectedTabPanelClassName:f,environment:h}=e;n.current=n.current||[];let m=n.current.length-l();const g=(0,r.useId)();for(;m++<0;)n.current.push(`${g}${n.current.length}`);return Yp(o,e=>{let o=e;if(Hp(e)){let i=0,l=!1;null==rd&&function(e){const t=e||("undefined"!=typeof window?window:void 0);try{rd=!(void 0===t||!t.document||!t.document.activeElement)}catch(e){rd=!1}}(h);const u=h||("undefined"!=typeof window?window:void 0);rd&&u&&(l=r.Children.toArray(e.props.children).filter(Wp).some((e,t)=>u.document.activeElement===c(t))),o=(0,r.cloneElement)(e,{children:Yp(e.props.children,e=>{const o=`tabs-${i}`,c=p===i,u={tabRef:e=>{t.current[o]=e},id:n.current[i],selected:c,focus:c&&(a||l)};return d&&(u.selectedClassName=d),s&&(u.disabledClassName=s),i++,(0,r.cloneElement)(e,u)})})}else if(Gp(e)){const t={id:n.current[i],selected:p===i};u&&(t.forceRender=u),f&&(t.selectedClassName=f),i++,o=(0,r.cloneElement)(e,t)}return o})}())};id.propTypes={};var od=id;const sd={defaultFocus:!1,focusTabOnClick:!0,forceRenderTabPanel:!1,selectedIndex:null,defaultIndex:null,environment:null,disableUpDownKeys:!1,disableLeftRightKeys:!1},ad=e=>{const{children:t,defaultFocus:n,defaultIndex:i,focusTabOnClick:o,onSelect:s,...a}={...sd,...e},[l,c]=(0,r.useState)(n),[u]=(0,r.useState)((e=>null===e.selectedIndex?1:0)(a)),[p,d]=(0,r.useState)(1===u?i||0:null);if((0,r.useEffect)(()=>{c(!1)},[]),1===u){const e=Jp(t);(0,r.useEffect)(()=>{if(null!=p){const t=Math.max(0,e-1);d(Math.min(p,t))}},[e])}let f={...e,...a};return f.focus=l,f.onSelect=(e,t,r)=>{"function"==typeof s&&!1===s(e,t,r)||(o&&c(!0),1===u&&d(e))},null!=p&&(f.selectedIndex=p),delete f.defaultFocus,delete f.defaultIndex,delete f.focusTabOnClick,r.createElement(od,f,t)};ad.propTypes={},ad.tabsRole="Tabs";var ld=ad;const cd={className:"react-tabs__tab-list"},ud=e=>{const{children:t,className:n,...i}={...cd,...e};return r.createElement("ul",Object.assign({},i,{className:Xp(n),role:"tablist"}),t)};ud.tabsRole="TabList",ud.propTypes={};var pd=ud;const dd="react-tabs__tab",fd={className:dd,disabledClassName:`${dd}--disabled`,focus:!1,id:null,selected:!1,selectedClassName:`${dd}--selected`},hd=e=>{let t=(0,r.useRef)();const{children:n,className:i,disabled:o,disabledClassName:s,focus:a,id:l,selected:c,selectedClassName:u,tabIndex:p,tabRef:d,...f}={...fd,...e};return(0,r.useEffect)(()=>{c&&a&&t.current.focus()},[c,a]),r.createElement("li",Object.assign({},f,{className:Xp(i,{[u]:c,[s]:o}),ref:e=>{t.current=e,d&&d(e)},role:"tab",id:`tab${l}`,"aria-selected":c?"true":"false","aria-disabled":o?"true":"false","aria-controls":`panel${l}`,tabIndex:p||(c?"0":null),"data-rttab":!0}),n)};hd.propTypes={},hd.tabsRole="Tab";var md=hd;const gd="react-tabs__tab-panel",yd={className:gd,forceRender:!1,selectedClassName:`${gd}--selected`},bd=e=>{const{children:t,className:n,forceRender:i,id:o,selected:s,selectedClassName:a,...l}={...yd,...e};return r.createElement("div",Object.assign({},l,{className:Xp(n,{[a]:s}),role:"tabpanel",id:`panel${o}`,"aria-labelledby":`tab${o}`}),i||s?t:null)};bd.tabsRole="TabPanel",bd.propTypes={};var vd=bd;const xd=gs(ld)` + > ul { + list-style: none; + padding: 0; + margin: 0; + margin: 0 -5px; + + > li { + padding: 5px 10px; + display: inline-block; + + background-color: ${({theme:e})=>e.codeBlock.backgroundColor}; + border-bottom: 1px solid rgba(0, 0, 0, 0.5); + cursor: pointer; + text-align: center; + outline: none; + color: ${({theme:e})=>Dn(e.colors.tonalOffset,e.rightPanel.textColor)}; + margin: 0 + ${({theme:e})=>`${e.spacing.unit}px ${e.spacing.unit}px ${e.spacing.unit}px`}; + border: 1px solid ${({theme:e})=>Dn(.05,e.codeBlock.backgroundColor)}; + border-radius: 5px; + min-width: 60px; + font-size: 0.9em; + font-weight: bold; + + &.react-tabs__tab--selected { + color: ${e=>e.theme.colors.text.primary}; + background: ${({theme:e})=>e.rightPanel.textColor}; + &:focus { + outline: auto; + } + } + + &:only-child { + flex: none; + min-width: 100px; + } + + &.tab-success { + color: ${e=>e.theme.colors.responses.success.tabTextColor}; + } + + &.tab-redirect { + color: ${e=>e.theme.colors.responses.redirect.tabTextColor}; + } + + &.tab-info { + color: ${e=>e.theme.colors.responses.info.tabTextColor}; + } + + &.tab-error { + color: ${e=>e.theme.colors.responses.error.tabTextColor}; + } + } + } + > .react-tabs__tab-panel { + background: ${({theme:e})=>e.codeBlock.backgroundColor}; + & > div, + & > pre { + padding: ${e=>4*e.theme.spacing.unit}px; + margin: 0; + } + + & > div > pre { + padding: 0; + } + } +`,wd=(gs(xd)` + > ul { + display: block; + > li { + padding: 2px 5px; + min-width: auto; + margin: 0 15px 0 0; + font-size: 13px; + font-weight: normal; + border-bottom: 1px dashed; + color: ${({theme:e})=>Dn(e.colors.tonalOffset,e.rightPanel.textColor)}; + border-radius: 0; + background: none; + + &:last-child { + margin-right: 0; + } + + &.react-tabs__tab--selected { + color: ${({theme:e})=>e.rightPanel.textColor}; + background: none; + } + } + } + > .react-tabs__tab-panel { + & > div, + & > pre { + padding: ${e=>2*e.theme.spacing.unit}px 0; + } + } +`,gs.div` + /** + * Based on prism-dark.css + */ + + code[class*='language-'], + pre[class*='language-'] { + /* color: white; + background: none; */ + text-shadow: 0 -0.1em 0.2em black; + text-align: left; + white-space: pre; + word-spacing: normal; + word-break: normal; + word-wrap: normal; + line-height: 1.5; + + -moz-tab-size: 4; + -o-tab-size: 4; + tab-size: 4; + + -webkit-hyphens: none; + -moz-hyphens: none; + -ms-hyphens: none; + hyphens: none; + } + + @media print { + code[class*='language-'], + pre[class*='language-'] { + text-shadow: none; + } + } + + /* Code blocks */ + pre[class*='language-'] { + padding: 1em; + margin: 0.5em 0; + overflow: auto; + } + + .token.comment, + .token.prolog, + .token.doctype, + .token.cdata { + color: hsl(30, 20%, 50%); + } + + .token.punctuation { + opacity: 0.7; + } + + .namespace { + opacity: 0.7; + } + + .token.property, + .token.tag, + .token.number, + .token.constant, + .token.symbol { + color: #4a8bb3; + } + + .token.boolean { + color: #e64441; + } + + .token.selector, + .token.attr-name, + .token.string, + .token.char, + .token.builtin, + .token.inserted { + color: #a0fbaa; + & + a, + & + a:visited { + color: #4ed2ba; + text-decoration: underline; + } + } + + .token.property.string { + color: white; + } + + .token.operator, + .token.entity, + .token.url, + .token.variable { + color: hsl(40, 90%, 60%); + } + + .token.atrule, + .token.attr-value, + .token.keyword { + color: hsl(350, 40%, 70%); + } + + .token.regex, + .token.important { + color: #e90; + } + + .token.important, + .token.bold { + font-weight: bold; + } + .token.italic { + font-style: italic; + } + + .token.entity { + cursor: help; + } + + .token.deleted { + color: red; + } + + ${ys("Prism")}; +`),kd=gs.div` + opacity: 0.7; + transition: opacity 0.3s ease; + text-align: right; + &:focus-within { + opacity: 1; + } + > button { + background-color: transparent; + border: 0; + color: inherit; + padding: 2px 10px; + font-family: ${({theme:e})=>e.typography.fontFamily}; + font-size: ${({theme:e})=>e.typography.fontSize}; + line-height: ${({theme:e})=>e.typography.lineHeight}; + cursor: pointer; + outline: 0; + + :hover, + :focus { + background: rgba(255, 255, 255, 0.1); + } + } +`,Sd=gs.div` + &:hover ${kd} { + opacity: 1; + } +`,Ed=gs(wd).attrs({as:"pre"})` + font-family: ${e=>e.theme.typography.code.fontFamily}; + font-size: ${e=>e.theme.typography.code.fontSize}; + overflow-x: auto; + margin: 0; + + white-space: ${({theme:e})=>e.typography.code.wrap?"pre-wrap":"pre"}; +`;function Od(e){return getComputedStyle(e)}function _d(e,t){for(var r in t){var n=t[r];"number"==typeof n&&(n+="px"),e.style[r]=n}return e}function Pd(e){var t=document.createElement("div");return t.className=e,t}var $d="undefined"!=typeof Element&&(Element.prototype.matches||Element.prototype.webkitMatchesSelector||Element.prototype.mozMatchesSelector||Element.prototype.msMatchesSelector);function Ad(e,t){if(!$d)throw new Error("No element matching method supported");return $d.call(e,t)}function Cd(e){e.remove?e.remove():e.parentNode&&e.parentNode.removeChild(e)}function jd(e,t){return Array.prototype.filter.call(e.children,function(e){return Ad(e,t)})}var Td=function(e){return"ps__thumb-"+e},Nd=function(e){return"ps__rail-"+e},Id="ps__child--consume",Rd="ps--focus",Ld="ps--clicking",Dd=function(e){return"ps--active-"+e},Md=function(e){return"ps--scrolling-"+e},zd={x:null,y:null};function Fd(e,t){var r=e.element.classList,n=Md(t);r.contains(n)?clearTimeout(zd[t]):r.add(n)}function Bd(e,t){zd[t]=setTimeout(function(){return e.isAlive&&e.element.classList.remove(Md(t))},e.settings.scrollingThreshold)}var Ud=function(e){this.element=e,this.handlers={}},qd={isEmpty:{configurable:!0}};Ud.prototype.bind=function(e,t){void 0===this.handlers[e]&&(this.handlers[e]=[]),this.handlers[e].push(t),this.element.addEventListener(e,t,!1)},Ud.prototype.unbind=function(e,t){var r=this;this.handlers[e]=this.handlers[e].filter(function(n){return!(!t||n===t)||(r.element.removeEventListener(e,n,!1),!1)})},Ud.prototype.unbindAll=function(){for(var e in this.handlers)this.unbind(e)},qd.isEmpty.get=function(){var e=this;return Object.keys(this.handlers).every(function(t){return 0===e.handlers[t].length})},Object.defineProperties(Ud.prototype,qd);var Vd=function(){this.eventElements=[]};function Wd(e){if("function"==typeof window.CustomEvent)return new CustomEvent(e);var t=document.createEvent("CustomEvent");return t.initCustomEvent(e,!1,!1,void 0),t}function Hd(e,t,r,n,i){var o;if(void 0===n&&(n=!0),void 0===i&&(i=!1),"top"===t)o=["contentHeight","containerHeight","scrollTop","y","up","down"];else{if("left"!==t)throw new Error("A proper axis should be provided");o=["contentWidth","containerWidth","scrollLeft","x","left","right"]}!function(e,t,r,n,i){var o=r[0],s=r[1],a=r[2],l=r[3],c=r[4],u=r[5];void 0===n&&(n=!0),void 0===i&&(i=!1);var p=e.element;e.reach[l]=null,p[a]<1&&(e.reach[l]="start"),p[a]>e[o]-e[s]-1&&(e.reach[l]="end"),t&&(p.dispatchEvent(Wd("ps-scroll-"+l)),t<0?p.dispatchEvent(Wd("ps-scroll-"+c)):t>0&&p.dispatchEvent(Wd("ps-scroll-"+u)),n&&function(e,t){Fd(e,t),Bd(e,t)}(e,l)),e.reach[l]&&(t||i)&&p.dispatchEvent(Wd("ps-"+l+"-reach-"+e.reach[l]))}(e,r,o,n,i)}function Gd(e){return parseInt(e,10)||0}Vd.prototype.eventElement=function(e){var t=this.eventElements.filter(function(t){return t.element===e})[0];return t||(t=new Ud(e),this.eventElements.push(t)),t},Vd.prototype.bind=function(e,t,r){this.eventElement(e).bind(t,r)},Vd.prototype.unbind=function(e,t,r){var n=this.eventElement(e);n.unbind(t,r),n.isEmpty&&this.eventElements.splice(this.eventElements.indexOf(n),1)},Vd.prototype.unbindAll=function(){this.eventElements.forEach(function(e){return e.unbindAll()}),this.eventElements=[]},Vd.prototype.once=function(e,t,r){var n=this.eventElement(e),i=function(e){n.unbind(t,i),r(e)};n.bind(t,i)};var Yd={isWebKit:"undefined"!=typeof document&&"WebkitAppearance"in document.documentElement.style,supportsTouch:"undefined"!=typeof window&&("ontouchstart"in window||"maxTouchPoints"in window.navigator&&window.navigator.maxTouchPoints>0||window.DocumentTouch&&document instanceof window.DocumentTouch),supportsIePointer:"undefined"!=typeof navigator&&navigator.msMaxTouchPoints,isChrome:"undefined"!=typeof navigator&&/Chrome/i.test(navigator&&navigator.userAgent)};function Kd(e){var t=e.element,r=Math.floor(t.scrollTop),n=t.getBoundingClientRect();e.containerWidth=Math.round(n.width),e.containerHeight=Math.round(n.height),e.contentWidth=t.scrollWidth,e.contentHeight=t.scrollHeight,t.contains(e.scrollbarXRail)||(jd(t,Nd("x")).forEach(function(e){return Cd(e)}),t.appendChild(e.scrollbarXRail)),t.contains(e.scrollbarYRail)||(jd(t,Nd("y")).forEach(function(e){return Cd(e)}),t.appendChild(e.scrollbarYRail)),!e.settings.suppressScrollX&&e.containerWidth+e.settings.scrollXMarginOffset=e.railXWidth-e.scrollbarXWidth&&(e.scrollbarXLeft=e.railXWidth-e.scrollbarXWidth),e.scrollbarYTop>=e.railYHeight-e.scrollbarYHeight&&(e.scrollbarYTop=e.railYHeight-e.scrollbarYHeight),function(e,t){var r={width:t.railXWidth},n=Math.floor(e.scrollTop);t.isRtl?r.left=t.negativeScrollAdjustment+e.scrollLeft+t.containerWidth-t.contentWidth:r.left=e.scrollLeft,t.isScrollbarXUsingBottom?r.bottom=t.scrollbarXBottom-n:r.top=t.scrollbarXTop+n,_d(t.scrollbarXRail,r);var i={top:n,height:t.railYHeight};t.isScrollbarYUsingRight?t.isRtl?i.right=t.contentWidth-(t.negativeScrollAdjustment+e.scrollLeft)-t.scrollbarYRight-t.scrollbarYOuterWidth-9:i.right=t.scrollbarYRight-e.scrollLeft:t.isRtl?i.left=t.negativeScrollAdjustment+e.scrollLeft+2*t.containerWidth-t.contentWidth-t.scrollbarYLeft-t.scrollbarYOuterWidth:i.left=t.scrollbarYLeft+e.scrollLeft,_d(t.scrollbarYRail,i),_d(t.scrollbarX,{left:t.scrollbarXLeft,width:t.scrollbarXWidth-t.railBorderXWidth}),_d(t.scrollbarY,{top:t.scrollbarYTop,height:t.scrollbarYHeight-t.railBorderYWidth})}(t,e),e.scrollbarXActive?t.classList.add(Dd("x")):(t.classList.remove(Dd("x")),e.scrollbarXWidth=0,e.scrollbarXLeft=0,t.scrollLeft=!0===e.isRtl?e.contentWidth:0),e.scrollbarYActive?t.classList.add(Dd("y")):(t.classList.remove(Dd("y")),e.scrollbarYHeight=0,e.scrollbarYTop=0,t.scrollTop=0)}function Qd(e,t){return e.settings.minScrollbarLength&&(t=Math.max(t,e.settings.minScrollbarLength)),e.settings.maxScrollbarLength&&(t=Math.min(t,e.settings.maxScrollbarLength)),t}function Xd(e,t){var r=t[0],n=t[1],i=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],u=t[8],p=e.element,d=null,f=null,h=null;function m(t){t.touches&&t.touches[0]&&(t[i]=t.touches[0].pageY),p[l]=d+h*(t[i]-f),Fd(e,c),Kd(e),t.stopPropagation(),t.type.startsWith("touch")&&t.changedTouches.length>1&&t.preventDefault()}function g(){Bd(e,c),e[u].classList.remove(Ld),e.event.unbind(e.ownerDocument,"mousemove",m)}function y(t,s){d=p[l],s&&t.touches&&(t[i]=t.touches[0].pageY),f=t[i],h=(e[n]-e[r])/(e[o]-e[a]),s?e.event.bind(e.ownerDocument,"touchmove",m):(e.event.bind(e.ownerDocument,"mousemove",m),e.event.once(e.ownerDocument,"mouseup",g),t.preventDefault()),e[u].classList.add(Ld),t.stopPropagation()}e.event.bind(e[s],"mousedown",function(e){y(e)}),e.event.bind(e[s],"touchstart",function(e){y(e,!0)})}var Jd={"click-rail":function(e){e.element,e.event.bind(e.scrollbarY,"mousedown",function(e){return e.stopPropagation()}),e.event.bind(e.scrollbarYRail,"mousedown",function(t){var r=t.pageY-window.pageYOffset-e.scrollbarYRail.getBoundingClientRect().top>e.scrollbarYTop?1:-1;e.element.scrollTop+=r*e.containerHeight,Kd(e),t.stopPropagation()}),e.event.bind(e.scrollbarX,"mousedown",function(e){return e.stopPropagation()}),e.event.bind(e.scrollbarXRail,"mousedown",function(t){var r=t.pageX-window.pageXOffset-e.scrollbarXRail.getBoundingClientRect().left>e.scrollbarXLeft?1:-1;e.element.scrollLeft+=r*e.containerWidth,Kd(e),t.stopPropagation()})},"drag-thumb":function(e){Xd(e,["containerWidth","contentWidth","pageX","railXWidth","scrollbarX","scrollbarXWidth","scrollLeft","x","scrollbarXRail"]),Xd(e,["containerHeight","contentHeight","pageY","railYHeight","scrollbarY","scrollbarYHeight","scrollTop","y","scrollbarYRail"])},keyboard:function(e){var t=e.element;e.event.bind(e.ownerDocument,"keydown",function(r){if(!(r.isDefaultPrevented&&r.isDefaultPrevented()||r.defaultPrevented)&&(Ad(t,":hover")||Ad(e.scrollbarX,":focus")||Ad(e.scrollbarY,":focus"))){var n,i=document.activeElement?document.activeElement:e.ownerDocument.activeElement;if(i){if("IFRAME"===i.tagName)i=i.contentDocument.activeElement;else for(;i.shadowRoot;)i=i.shadowRoot.activeElement;if(Ad(n=i,"input,[contenteditable]")||Ad(n,"select,[contenteditable]")||Ad(n,"textarea,[contenteditable]")||Ad(n,"button,[contenteditable]"))return}var o=0,s=0;switch(r.which){case 37:o=r.metaKey?-e.contentWidth:r.altKey?-e.containerWidth:-30;break;case 38:s=r.metaKey?e.contentHeight:r.altKey?e.containerHeight:30;break;case 39:o=r.metaKey?e.contentWidth:r.altKey?e.containerWidth:30;break;case 40:s=r.metaKey?-e.contentHeight:r.altKey?-e.containerHeight:-30;break;case 32:s=r.shiftKey?e.containerHeight:-e.containerHeight;break;case 33:s=e.containerHeight;break;case 34:s=-e.containerHeight;break;case 36:s=e.contentHeight;break;case 35:s=-e.contentHeight;break;default:return}e.settings.suppressScrollX&&0!==o||e.settings.suppressScrollY&&0!==s||(t.scrollTop-=s,t.scrollLeft+=o,Kd(e),function(r,n){var i=Math.floor(t.scrollTop);if(0===r){if(!e.scrollbarYActive)return!1;if(0===i&&n>0||i>=e.contentHeight-e.containerHeight&&n<0)return!e.settings.wheelPropagation}var o=t.scrollLeft;if(0===n){if(!e.scrollbarXActive)return!1;if(0===o&&r<0||o>=e.contentWidth-e.containerWidth&&r>0)return!e.settings.wheelPropagation}return!0}(o,s)&&r.preventDefault())}})},wheel:function(e){var t=e.element;function r(r){var n=function(e){var t=e.deltaX,r=-1*e.deltaY;return void 0!==t&&void 0!==r||(t=-1*e.wheelDeltaX/6,r=e.wheelDeltaY/6),e.deltaMode&&1===e.deltaMode&&(t*=10,r*=10),t!=t&&r!=r&&(t=0,r=e.wheelDelta),e.shiftKey?[-r,-t]:[t,r]}(r),i=n[0],o=n[1];if(!function(e,r,n){if(!Yd.isWebKit&&t.querySelector("select:focus"))return!0;if(!t.contains(e))return!1;for(var i=e;i&&i!==t;){if(i.classList.contains(Id))return!0;var o=Od(i);if(n&&o.overflowY.match(/(scroll|auto)/)){var s=i.scrollHeight-i.clientHeight;if(s>0&&(i.scrollTop>0&&n<0||i.scrollTop0))return!0}if(r&&o.overflowX.match(/(scroll|auto)/)){var a=i.scrollWidth-i.clientWidth;if(a>0&&(i.scrollLeft>0&&r<0||i.scrollLeft0))return!0}i=i.parentNode}return!1}(r.target,i,o)){var s=!1;e.settings.useBothWheelAxes?e.scrollbarYActive&&!e.scrollbarXActive?(o?t.scrollTop-=o*e.settings.wheelSpeed:t.scrollTop+=i*e.settings.wheelSpeed,s=!0):e.scrollbarXActive&&!e.scrollbarYActive&&(i?t.scrollLeft+=i*e.settings.wheelSpeed:t.scrollLeft-=o*e.settings.wheelSpeed,s=!0):(t.scrollTop-=o*e.settings.wheelSpeed,t.scrollLeft+=i*e.settings.wheelSpeed),Kd(e),s=s||function(r,n){var i=Math.floor(t.scrollTop),o=0===t.scrollTop,s=i+t.offsetHeight===t.scrollHeight,a=0===t.scrollLeft,l=t.scrollLeft+t.offsetWidth===t.scrollWidth;return!(Math.abs(n)>Math.abs(r)?o||s:a||l)||!e.settings.wheelPropagation}(i,o),s&&!r.ctrlKey&&(r.stopPropagation(),r.preventDefault())}}void 0!==window.onwheel?e.event.bind(t,"wheel",r):void 0!==window.onmousewheel&&e.event.bind(t,"mousewheel",r)},touch:function(e){if(Yd.supportsTouch||Yd.supportsIePointer){var t=e.element,r={},n=0,i={},o=null;Yd.supportsTouch?(e.event.bind(t,"touchstart",c),e.event.bind(t,"touchmove",u),e.event.bind(t,"touchend",p)):Yd.supportsIePointer&&(window.PointerEvent?(e.event.bind(t,"pointerdown",c),e.event.bind(t,"pointermove",u),e.event.bind(t,"pointerup",p)):window.MSPointerEvent&&(e.event.bind(t,"MSPointerDown",c),e.event.bind(t,"MSPointerMove",u),e.event.bind(t,"MSPointerUp",p)))}function s(r,n){t.scrollTop-=n,t.scrollLeft-=r,Kd(e)}function a(e){return e.targetTouches?e.targetTouches[0]:e}function l(e){return!(e.pointerType&&"pen"===e.pointerType&&0===e.buttons||(!e.targetTouches||1!==e.targetTouches.length)&&(!e.pointerType||"mouse"===e.pointerType||e.pointerType===e.MSPOINTER_TYPE_MOUSE))}function c(e){if(l(e)){var t=a(e);r.pageX=t.pageX,r.pageY=t.pageY,n=(new Date).getTime(),null!==o&&clearInterval(o)}}function u(o){if(l(o)){var c=a(o),u={pageX:c.pageX,pageY:c.pageY},p=u.pageX-r.pageX,d=u.pageY-r.pageY;if(function(e,r,n){if(!t.contains(e))return!1;for(var i=e;i&&i!==t;){if(i.classList.contains(Id))return!0;var o=Od(i);if(n&&o.overflowY.match(/(scroll|auto)/)){var s=i.scrollHeight-i.clientHeight;if(s>0&&(i.scrollTop>0&&n<0||i.scrollTop0))return!0}if(r&&o.overflowX.match(/(scroll|auto)/)){var a=i.scrollWidth-i.clientWidth;if(a>0&&(i.scrollLeft>0&&r<0||i.scrollLeft0))return!0}i=i.parentNode}return!1}(o.target,p,d))return;s(p,d),r=u;var f=(new Date).getTime(),h=f-n;h>0&&(i.x=p/h,i.y=d/h,n=f),function(r,n){var i=Math.floor(t.scrollTop),o=t.scrollLeft,s=Math.abs(r),a=Math.abs(n);if(a>s){if(n<0&&i===e.contentHeight-e.containerHeight||n>0&&0===i)return 0===window.scrollY&&n>0&&Yd.isChrome}else if(s>a&&(r<0&&o===e.contentWidth-e.containerWidth||r>0&&0===o))return!0;return!0}(p,d)&&o.preventDefault()}}function p(){e.settings.swipeEasing&&(clearInterval(o),o=setInterval(function(){e.isInitialized?clearInterval(o):i.x||i.y?Math.abs(i.x)<.01&&Math.abs(i.y)<.01?clearInterval(o):e.element?(s(30*i.x,30*i.y),i.x*=.8,i.y*=.8):clearInterval(o):clearInterval(o)},10))}}},Zd=function(e,t){var r=this;if(void 0===t&&(t={}),"string"==typeof e&&(e=document.querySelector(e)),!e||!e.nodeName)throw new Error("no element is specified to initialize PerfectScrollbar");for(var n in this.element=e,e.classList.add("ps"),this.settings={handlers:["click-rail","drag-thumb","keyboard","wheel","touch"],maxScrollbarLength:null,minScrollbarLength:null,scrollingThreshold:1e3,scrollXMarginOffset:0,scrollYMarginOffset:0,suppressScrollX:!1,suppressScrollY:!1,swipeEasing:!0,useBothWheelAxes:!1,wheelPropagation:!0,wheelSpeed:1},t)this.settings[n]=t[n];this.containerWidth=null,this.containerHeight=null,this.contentWidth=null,this.contentHeight=null;var i,o,s=function(){return e.classList.add(Rd)},a=function(){return e.classList.remove(Rd)};this.isRtl="rtl"===Od(e).direction,!0===this.isRtl&&e.classList.add("ps__rtl"),this.isNegativeScroll=(o=e.scrollLeft,e.scrollLeft=-1,i=e.scrollLeft<0,e.scrollLeft=o,i),this.negativeScrollAdjustment=this.isNegativeScroll?e.scrollWidth-e.clientWidth:0,this.event=new Vd,this.ownerDocument=e.ownerDocument||document,this.scrollbarXRail=Pd(Nd("x")),e.appendChild(this.scrollbarXRail),this.scrollbarX=Pd(Td("x")),this.scrollbarXRail.appendChild(this.scrollbarX),this.scrollbarX.setAttribute("tabindex",0),this.event.bind(this.scrollbarX,"focus",s),this.event.bind(this.scrollbarX,"blur",a),this.scrollbarXActive=null,this.scrollbarXWidth=null,this.scrollbarXLeft=null;var l=Od(this.scrollbarXRail);this.scrollbarXBottom=parseInt(l.bottom,10),isNaN(this.scrollbarXBottom)?(this.isScrollbarXUsingBottom=!1,this.scrollbarXTop=Gd(l.top)):this.isScrollbarXUsingBottom=!0,this.railBorderXWidth=Gd(l.borderLeftWidth)+Gd(l.borderRightWidth),_d(this.scrollbarXRail,{display:"block"}),this.railXMarginWidth=Gd(l.marginLeft)+Gd(l.marginRight),_d(this.scrollbarXRail,{display:""}),this.railXWidth=null,this.railXRatio=null,this.scrollbarYRail=Pd(Nd("y")),e.appendChild(this.scrollbarYRail),this.scrollbarY=Pd(Td("y")),this.scrollbarYRail.appendChild(this.scrollbarY),this.scrollbarY.setAttribute("tabindex",0),this.event.bind(this.scrollbarY,"focus",s),this.event.bind(this.scrollbarY,"blur",a),this.scrollbarYActive=null,this.scrollbarYHeight=null,this.scrollbarYTop=null;var c=Od(this.scrollbarYRail);this.scrollbarYRight=parseInt(c.right,10),isNaN(this.scrollbarYRight)?(this.isScrollbarYUsingRight=!1,this.scrollbarYLeft=Gd(c.left)):this.isScrollbarYUsingRight=!0,this.scrollbarYOuterWidth=this.isRtl?function(e){var t=Od(e);return Gd(t.width)+Gd(t.paddingLeft)+Gd(t.paddingRight)+Gd(t.borderLeftWidth)+Gd(t.borderRightWidth)}(this.scrollbarY):null,this.railBorderYWidth=Gd(c.borderTopWidth)+Gd(c.borderBottomWidth),_d(this.scrollbarYRail,{display:"block"}),this.railYMarginHeight=Gd(c.marginTop)+Gd(c.marginBottom),_d(this.scrollbarYRail,{display:""}),this.railYHeight=null,this.railYRatio=null,this.reach={x:e.scrollLeft<=0?"start":e.scrollLeft>=this.contentWidth-this.containerWidth?"end":null,y:e.scrollTop<=0?"start":e.scrollTop>=this.contentHeight-this.containerHeight?"end":null},this.isAlive=!0,this.settings.handlers.forEach(function(e){return Jd[e](r)}),this.lastScrollTop=Math.floor(e.scrollTop),this.lastScrollLeft=e.scrollLeft,this.event.bind(this.element,"scroll",function(e){return r.onScroll(e)}),Kd(this)};Zd.prototype.update=function(){this.isAlive&&(this.negativeScrollAdjustment=this.isNegativeScroll?this.element.scrollWidth-this.element.clientWidth:0,_d(this.scrollbarXRail,{display:"block"}),_d(this.scrollbarYRail,{display:"block"}),this.railXMarginWidth=Gd(Od(this.scrollbarXRail).marginLeft)+Gd(Od(this.scrollbarXRail).marginRight),this.railYMarginHeight=Gd(Od(this.scrollbarYRail).marginTop)+Gd(Od(this.scrollbarYRail).marginBottom),_d(this.scrollbarXRail,{display:"none"}),_d(this.scrollbarYRail,{display:"none"}),Kd(this),Hd(this,"top",0,!1,!0),Hd(this,"left",0,!1,!0),_d(this.scrollbarXRail,{display:""}),_d(this.scrollbarYRail,{display:""}))},Zd.prototype.onScroll=function(e){this.isAlive&&(Kd(this),Hd(this,"top",this.element.scrollTop-this.lastScrollTop),Hd(this,"left",this.element.scrollLeft-this.lastScrollLeft),this.lastScrollTop=Math.floor(this.element.scrollTop),this.lastScrollLeft=this.element.scrollLeft)},Zd.prototype.destroy=function(){this.isAlive&&(this.event.unbindAll(),Cd(this.scrollbarX),Cd(this.scrollbarY),Cd(this.scrollbarXRail),Cd(this.scrollbarYRail),this.removePsClasses(),this.element=null,this.scrollbarX=null,this.scrollbarY=null,this.scrollbarXRail=null,this.scrollbarYRail=null,this.isAlive=!1)},Zd.prototype.removePsClasses=function(){this.element.className=this.element.className.split(" ").filter(function(e){return!e.match(/^ps([-_].+|)$/)}).join(" ")};var ef=Zd,tf=Object.defineProperty,rf=Object.getOwnPropertySymbols,nf=Object.prototype.hasOwnProperty,of=Object.prototype.propertyIsEnumerable,sf=(e,t,r)=>t in e?tf(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;const af=ef||t;let lf="";Qn&&(lf=n(1494),lf="function"==typeof lf.toString&&lf.toString()||"",lf="[object Object]"===lf?"":lf);const cf=ds`${lf}`,uf=gs.div` + position: relative; +`;class pf extends r.Component{constructor(){super(...arguments),this.handleRef=e=>{this._container=e}}componentDidMount(){const e=this._container.parentElement&&this._container.parentElement.scrollTop||0;this.inst=new af(this._container,this.props.options||{}),this._container.scrollTo&&this._container.scrollTo(0,e)}componentDidUpdate(){this.inst.update()}componentWillUnmount(){this.inst.destroy()}render(){const{children:e,className:t,updateFn:n}=this.props;return n&&n(this.componentDidUpdate.bind(this)),r.createElement(r.Fragment,null,lf&&r.createElement(cf,null),r.createElement(uf,{className:`scrollbar-container ${t}`,ref:this.handleRef},e))}}function df(e){return r.createElement(Os.Consumer,null,t=>t.nativeScrollbars?r.createElement("div",{style:{overflow:"auto",overscrollBehavior:"contain",msOverflowStyle:"-ms-autohiding-scrollbar"}},e.children):r.createElement(pf,((e,t)=>{for(var r in t||(t={}))nf.call(t,r)&&sf(e,r,t[r]);if(rf)for(var r of rf(t))of.call(t,r)&&sf(e,r,t[r]);return e})({},e),e.children))}const ff=gs(({className:e,style:t})=>r.createElement("svg",{className:e,style:t,xmlns:"http://www.w3.org/2000/svg",width:"16",height:"16",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round"},r.createElement("polyline",{points:"6 9 12 15 18 9"})))` + position: absolute; + pointer-events: none; + z-index: 1; + top: 50%; + -webkit-transform: translateY(-50%); + -ms-transform: translateY(-50%); + transform: translateY(-50%); + right: 8px; + margin: auto; + text-align: center; + polyline { + color: ${e=>"dark"===e.variant&&"white"}; + } +`,hf=r.memo(e=>{const{options:t,onChange:n,placeholder:i,value:o="",variant:s,className:a}=e;return r.createElement("div",{className:a},r.createElement(ff,{variant:s}),r.createElement("select",{onChange:e=>{const{selectedIndex:r}=e.target;n(t[i?r-1:r])},value:o,className:"dropdown-select"},i&&r.createElement("option",{disabled:!0,hidden:!0,value:i},i),t.map(({idx:e,value:t,title:n},i)=>r.createElement("option",{key:e||t+i,value:t},n||t))),r.createElement("label",null,o))}),mf=cs(hf)` + label { + box-sizing: border-box; + min-width: 100px; + outline: none; + display: inline-block; + font-family: ${e=>e.theme.typography.headings.fontFamily}; + color: ${({theme:e})=>e.colors.text.primary}; + vertical-align: bottom; + width: ${({fullWidth:e})=>e?"100%":"auto"}; + text-transform: none; + padding: 0 22px 0 4px; + + font-size: 0.929em; + line-height: 1.5em; + font-family: inherit; + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; + } + .dropdown-select { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + opacity: 0; + border: none; + appearance: none; + cursor: pointer; + + color: ${({theme:e})=>e.colors.text.primary}; + line-height: inherit; + font-family: inherit; + } + box-sizing: border-box; + min-width: 100px; + outline: none; + display: inline-block; + border-radius: 2px; + border: 1px solid rgba(38, 50, 56, 0.5); + vertical-align: bottom; + padding: 2px 0px 2px 6px; + position: relative; + width: auto; + background: white; + color: #263238; + font-family: ${e=>e.theme.typography.headings.fontFamily}; + font-size: 0.929em; + line-height: 1.5em; + cursor: pointer; + transition: border 0.25s ease, color 0.25s ease, box-shadow 0.25s ease; + + &:hover, + &:focus-within { + border: 1px solid ${e=>e.theme.colors.primary.main}; + color: ${e=>e.theme.colors.primary.main}; + box-shadow: 0px 0px 0px 1px ${e=>e.theme.colors.primary.main}; + } +`,gf=cs(mf)` + margin-left: 10px; + text-transform: none; + font-size: 0.969em; + + font-size: 1em; + border: none; + padding: 0 1.2em 0 0; + background: transparent; + + &:hover, + &:focus-within { + border: none; + box-shadow: none; + label { + color: ${e=>e.theme.colors.primary.main}; + text-shadow: 0px 0px 0px ${e=>e.theme.colors.primary.main}; + } + } +`,yf=cs.span` + margin-left: 10px; + text-transform: none; + font-size: 0.929em; + color: black; +`;var bf=Object.defineProperty,vf=Object.defineProperties,xf=Object.getOwnPropertyDescriptors,wf=Object.getOwnPropertySymbols,kf=Object.prototype.hasOwnProperty,Sf=Object.prototype.propertyIsEnumerable,Ef=(e,t,r)=>t in e?bf(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Of=(e,t)=>{for(var r in t||(t={}))kf.call(t,r)&&Ef(e,r,t[r]);if(wf)for(var r of wf(t))Sf.call(t,r)&&Ef(e,r,t[r]);return e},_f=(e,t)=>vf(e,xf(t));class Pf{constructor(e,t,r){this.operations=[];const{resolved:n}=e.deref(r||{});this.initWebhooks(e,n,t)}initWebhooks(e,t,r){for(const n of Object.keys(t)){const i=t[n],o=Object.keys(i).filter(Xs);for(const t of o){const n=i[t];if(i.$ref){const n=e.deref(i||{});this.initWebhooks(e,{[t]:n},r)}if(!n)continue;const o=new ap(e,_f(Of({},n),{httpVerb:t}),void 0,r,!1);this.operations.push(o)}}}}class $f{constructor(e,t,r){const{resolved:n}=e.deref(r);this.id=t,this.sectionId=ya+t,this.type=n.type,this.displayName=n["x-displayName"]||t,this.description=n.description||"","apiKey"===n.type&&(this.apiKey={name:n.name,in:n.in}),"http"===n.type&&(this.http={scheme:n.scheme,bearerFormat:n.bearerFormat}),"openIdConnect"===n.type&&(this.openId={connectUrl:n.openIdConnectUrl}),"oauth2"===n.type&&n.flows&&(this.flows=n.flows)}}class Af{constructor(e){const t=e.spec.components&&e.spec.components.securitySchemes||{};this.schemes=Object.keys(t).map(r=>new $f(e,r,t[r]))}}var Cf=Object.defineProperty,jf=Object.getOwnPropertySymbols,Tf=Object.prototype.hasOwnProperty,Nf=Object.prototype.propertyIsEnumerable,If=(e,t,r)=>t in e?Cf(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Rf=(e,t)=>{for(var r in t||(t={}))Tf.call(t,r)&&If(e,r,t[r]);if(jf)for(var r of jf(t))Nf.call(t,r)&&If(e,r,t[r]);return e};class Lf{constructor(e,t,r){var n,i,o;this.options=r,this.parser=new yc(e,t,r),this.info=new Ml(this.parser,this.options),this.externalDocs=this.parser.spec.externalDocs,this.contentItems=Qf.buildStructure(this.parser,this.options),this.securitySchemes=new Af(this.parser);const s=Rf(Rf({},null==(i=null==(n=this.parser)?void 0:n.spec)?void 0:i["x-webhooks"]),null==(o=this.parser)?void 0:o.spec.webhooks);this.webhooks=new Pf(this.parser,r,s)}}var Df=Object.defineProperty,Mf=Object.getOwnPropertyDescriptor,zf=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Mf(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Df(t,r,o),o};class Ff{constructor(e,t,r){this.items=[],this.active=!1,this.expanded=!1,ir(this),this.id=t.id||e+"/"+li(t.name),this.type=e,this.name=t["x-displayName"]||t.name,this.level=t.level||1,this.sidebarLabel=this.name,this.description=t.description||"";const n=t.items;n&&n.length&&(this.description=Ll.getTextBeforeHading(this.description,n[0].name)),this.parent=r,this.externalDocs=t.externalDocs,"group"===this.type&&(this.expanded=!0)}activate(){this.active=!0}expand(){this.parent&&this.parent.expand(),this.expanded=!0}collapse(){"group"!==this.type&&(this.expanded=!1)}deactivate(){this.active=!1}}zf([Ce],Ff.prototype,"active",2),zf([Ce],Ff.prototype,"expanded",2),zf([Ct],Ff.prototype,"activate",1),zf([Ct],Ff.prototype,"expand",1),zf([Ct],Ff.prototype,"collapse",1),zf([Ct],Ff.prototype,"deactivate",1);var Bf=Object.defineProperty,Uf=Object.defineProperties,qf=Object.getOwnPropertyDescriptors,Vf=Object.getOwnPropertySymbols,Wf=Object.prototype.hasOwnProperty,Hf=Object.prototype.propertyIsEnumerable,Gf=(e,t,r)=>t in e?Bf(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Yf=(e,t)=>{for(var r in t||(t={}))Wf.call(t,r)&&Gf(e,r,t[r]);if(Vf)for(var r of Vf(t))Hf.call(t,r)&&Gf(e,r,t[r]);return e},Kf=(e,t)=>Uf(e,qf(t));class Qf{static buildStructure(e,t){const r=e.spec,{schemaDefinitionsTagName:n}=t,i=[],o=[...r.tags||[]];!o.find(e=>(null==e?void 0:e.name)===n)&&n&&o.push({name:n});const s=Qf.getTagsWithOperations(e,o);return i.push(...Qf.addMarkdownItems(r.info.description||"",void 0,1,t)),r["x-tagGroups"]&&r["x-tagGroups"].length>0?i.push(...Qf.getTagGroupsItems(e,void 0,r["x-tagGroups"],s,t)):i.push(...Qf.getTagsItems(e,s,void 0,void 0,t)),i}static addMarkdownItems(e,t,r,n){const i=new Ll(n,null==t?void 0:t.id).extractHeadings(e||"");i.length&&t&&t.description&&(t.description=Ll.getTextBeforeHading(t.description,i[0].name));const o=(e,t,r=1)=>t.map(t=>{const n=new Ff("section",t,e);return n.depth=r,t.items&&(n.items=o(n,t.items,r+1)),n});return o(t,i,r)}static getTagGroupsItems(e,t,r,n,i){const o=[];for(const s of r){const r=new Ff("group",s,t);r.depth=0,r.items=Qf.getTagsItems(e,n,r,s,i),o.push(r)}return o}static getTagsItems(e,t,r,n,i){let o;o=void 0===n?Object.keys(t):n.tags;const s=o.map(e=>t[e]?(t[e].used=!0,t[e]):(console.warn(`Non-existing tag "${e}" is added to the group "${n.name}"`),null)),a=[];for(const t of s){if(!t)continue;const n=new Ff("tag",t,r);if(n.depth=1,""===t.name){const r=[...Qf.addMarkdownItems(t.description||"",n,n.depth+1,i),...this.getOperationsItems(e,void 0,t,n.depth+1,i)];a.push(...r);continue}const o=this.getTagRelatedSchema({parser:e,tag:t,parent:n,schemaDefinitionsTagName:i.schemaDefinitionsTagName});n.items=[...o,...Qf.addMarkdownItems(t.description||"",n,n.depth+1,i),...this.getOperationsItems(e,n,t,n.depth+1,i)],a.push(n)}return i.sortTagsAlphabetically&&a.sort(Ia("name")),a}static getOperationsItems(e,t,r,n,i){if(0===r.operations.length)return[];const o=[];for(const s of r.operations){const r=new ap(e,s,t,i);r.depth=n,o.push(r)}return i.sortOperationsAlphabetically&&o.sort(Ia("name")),o}static getTagsWithOperations(e,t){const{spec:r}=e,n={},i=r["x-webhooks"]||r.webhooks;for(const e of t||[])n[e.name]=Kf(Yf({},e),{operations:[]});function o(e,t,r){for(const i of Object.keys(t)){const s=t[i],a=Object.keys(s).filter(Xs);for(const t of a){const a=s[t];if(s.$ref){const{resolved:t}=e.deref(s);o(e,{[i]:t},r);continue}let l=null==a?void 0:a.tags;l&&l.length||(l=[""]);for(const e of l){let o=n[e];void 0===o&&(o={name:e,operations:[]},n[e]=o),o["x-traitTag"]||o.operations.push(Kf(Yf({},a),{pathName:i,pointer:Ls.compile(["paths",i,t]),httpVerb:t,pathParameters:s.parameters||[],pathServers:s.servers,isWebhook:!!r}))}}}}return i&&o(e,i,!0),r.paths&&o(e,r.paths),n}static getTagRelatedSchema({parser:e,tag:t,parent:r,schemaDefinitionsTagName:n}){var i;const o=n?[n]:[];return Object.entries((null==(i=e.spec.components)?void 0:i.schemas)||{}).map(([e,n])=>{const i=n["x-tags"]||o;if(!(null==i?void 0:i.includes(t.name)))return null;const s=new Ff("schema",{name:e,"x-displayName":`${n.title||e}`,description:``},r);return s.depth=r.depth+1,s}).filter(Boolean)}}var Xf=Object.defineProperty,Jf=Object.getOwnPropertyDescriptor,Zf=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Jf(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Xf(t,r,o),o};const eh="data-section-id";class th{constructor(e,t,r){this.scroll=t,this.history=r,this.activeItemIdx=-1,this.sideBarOpened=!1,this.updateOnScroll=e=>{const t=e?1:-1;let r=this.activeItemIdx;for(;(-1!==r||e)&&!(r>=this.flatItems.length-1&&e);){if(e){const e=this.getElementAtOrFirstChild(r+1);if(this.scroll.isElementBellow(e))break}else{const e=this.getElementAt(r);if(this.scroll.isElementAbove(e))break}r+=t}this.activate(this.flatItems[r],!0,!0)},this.updateOnHistory=(e=this.history.currentId)=>{if(!e)return;let t;t=this.flatItems.find(t=>t.id===e),t?this.activateAndScroll(t,!1):(e.startsWith(ya)&&(t=this.flatItems.find(e=>ya.startsWith(e.id)),this.activateAndScroll(t,!1)),this.scroll.scrollIntoViewBySelector(`[${eh}="${ui(e)}"]`))},this.getItemById=e=>this.flatItems.find(t=>t.id===e),ir(this),this.items=e.contentItems,this.flatItems=function(e,t){const r=[],n=e=>{for(const i of e)r.push(i),i[t]&&n(i[t])};return n(e),r}(this.items||[],"items"),this.flatItems.forEach((e,t)=>e.absoluteIdx=t),this.subscribe()}static updateOnHistory(e=za.currentId,t){e&&t.scrollIntoViewBySelector(`[${eh}="${ui(e)}"]`)}subscribe(){this._unsubscribe=this.scroll.subscribe(this.updateOnScroll),this._hashUnsubscribe=this.history.subscribe(this.updateOnHistory)}toggleSidebar(){this.sideBarOpened=!this.sideBarOpened}closeSidebar(){this.sideBarOpened=!1}getElementAt(e){const t=this.flatItems[e];return t&&Xn(`[${eh}="${ui(t.id)}"]`)||null}getElementAtOrFirstChild(e){let t=this.flatItems[e];return t&&"group"===t.type&&(t=t.items[0]),t&&Xn(`[${eh}="${ui(t.id)}"]`)||null}get activeItem(){return this.flatItems[this.activeItemIdx]||void 0}activate(e,t=!0,r=!1){if((this.activeItem&&this.activeItem.id)!==(e&&e.id)&&(!e||"group"!==e.type)){if(this.deactivate(this.activeItem),!e)return this.activeItemIdx=-1,void this.history.replace("",r);e.depth<=0||(this.activeItemIdx=e.absoluteIdx,t&&this.history.replace(encodeURI(e.id),r),e.activate(),e.expand())}}deactivate(e){if(void 0!==e)for(e.deactivate();void 0!==e;)e.collapse(),e=e.parent}activateAndScroll(e,t,r){const n=e&&this.getItemById(e.id)||e;this.activate(n,t,r),this.scrollToActive(),n&&n.items.length||this.closeSidebar()}scrollToActive(){this.scroll.scrollIntoView(this.getElementAt(this.activeItemIdx))}dispose(){this._unsubscribe(),this._hashUnsubscribe()}}Zf([Ce],th.prototype,"activeItemIdx",2),Zf([Ce],th.prototype,"sideBarOpened",2),Zf([Ct],th.prototype,"toggleSidebar",1),Zf([Ct],th.prototype,"closeSidebar",1),Zf([Ct],th.prototype,"activate",1),Zf([Ct.bound],th.prototype,"activateAndScroll",1);var rh=Object.defineProperty,nh=Object.getOwnPropertyDescriptor;const ih="scroll";class oh{constructor(e){this.options=e,this._prevOffsetY=0,this._scrollParent=Qn?window:void 0,this._emiter=new Ts,this.bind()}bind(){this._prevOffsetY=this.scrollY(),this._scrollParent&&this._scrollParent.addEventListener("scroll",this.handleScroll)}dispose(){this._scrollParent&&this._scrollParent.removeEventListener("scroll",this.handleScroll),this._emiter.removeAllListeners(ih)}scrollY(){return"undefined"!=typeof HTMLElement&&this._scrollParent instanceof HTMLElement?this._scrollParent.scrollTop:void 0!==this._scrollParent?this._scrollParent.pageYOffset:0}isElementBellow(e){if(null!==e)return e.getBoundingClientRect().top>this.options.scrollYOffset()}isElementAbove(e){if(null===e)return;const t=e.getBoundingClientRect().top;return(t>0?Math.floor(t):Math.ceil(t))<=this.options.scrollYOffset()}subscribe(e){const t=this._emiter.addListener(ih,e);return()=>t.removeListener(ih,e)}scrollIntoView(e){null!==e&&(e.scrollIntoView(),this._scrollParent&&this._scrollParent.scrollBy&&this._scrollParent.scrollBy(0,1-this.options.scrollYOffset()))}scrollIntoViewBySelector(e){const t=Xn(e);this.scrollIntoView(t)}handleScroll(){const e=this.scrollY()-this._prevOffsetY>0;this._prevOffsetY=this.scrollY(),this._emiter.emit(ih,e)}}((e,t,r)=>{for(var n,i=nh(t,r),o=e.length-1;o>=0;o--)(n=e[o])&&(i=n(t,r,i)||i);i&&rh(t,r,i)})([js.bind,(e,t,r)=>{r.value=function(e){let t,r,n,i=null,o=0;const s=()=>{o=(new Date).getTime(),i=null,n=e.apply(t,r),i||(t=r=null)};return function(){const a=(new Date).getTime(),l=100-(a-o);return t=this,r=arguments,l<=0||l>100?(i&&(clearTimeout(i),i=null),o=a,n=e.apply(t,r),i||(t=r=null)):i||(i=setTimeout(s,l)),n}}(r.value)}],oh.prototype,"handleScroll");class sh{constructor(){this.searchWorker=function(){let e;if(Qn)try{e=n(3303)}catch(t){e=n(1714).default}else e=n(1714).default;return new e}()}indexItems(e){const t=e=>{e.forEach(e=>{"group"!==e.type&&this.add(e.name,(e.description||"").concat(" ",e.path||""),e.id),t(e.items)})};t(e),this.searchWorker.done()}add(e,t,r){this.searchWorker.add(e,t,r)}dispose(){this.searchWorker.terminate(),this.searchWorker.dispose()}search(e){return this.searchWorker.search(e)}toJS(){return e=this,t=function*(){return this.searchWorker.toJS()},new Promise((r,n)=>{var i=e=>{try{s(t.next(e))}catch(e){n(e)}},o=e=>{try{s(t.throw(e))}catch(e){n(e)}},s=e=>e.done?r(e.value):Promise.resolve(e.value).then(i,o);s((t=t.apply(e,null)).next())});var e,t}load(e){this.searchWorker.load(e)}fromExternalJS(e,t){e&&t&&this.searchWorker.fromExternalJS(e,t)}}var ah=Object.defineProperty,lh=Object.getOwnPropertySymbols,ch=Object.prototype.hasOwnProperty,uh=Object.prototype.propertyIsEnumerable,ph=(e,t,r)=>t in e?ah(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;function dh(e){const{Label:t=yf,Dropdown:n=gf}=e;return 1===e.options.length?r.createElement(t,null,e.options[0].value):r.createElement(n,((e,t)=>{for(var r in t||(t={}))ch.call(t,r)&&ph(e,r,t[r]);if(lh)for(var r of lh(t))uh.call(t,r)&&ph(e,r,t[r]);return e})({},e))}function fh(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=Array(t);r2?r-2:0),i=2;i1?t-1:0),n=1;n1?r-1:0),i=1;i2&&void 0!==arguments[2]?arguments[2]:Th;if(gh&&gh(e,null),!jh(t))return e;let n=t.length;for(;n--;){let i=t[n];if("string"==typeof i){const e=r(i);e!==i&&(yh(t)||(t[n]=e),i=e)}e[i]=!0}return e}function Kh(e){for(let t=0;t/g),pm=wh(/\${[\w\W]*/g),dm=wh(/^data-[\-\w.\u00B7-\uFFFF]+$/),fm=wh(/^aria-[\-\w]+$/),hm=wh(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),mm=wh(/^(?:\w+script|data):/i),gm=wh(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),ym=wh(/^html$/i),bm=wh(/^[a-z][.\w]*(-[.\w]+)+$/i),vm=function(){return"undefined"==typeof window?null:window};var xm=function e(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:vm();const r=t=>e(t);if(r.version="3.4.6",r.removed=[],!t||!t.document||9!==t.document.nodeType||!t.Element)return r.isSupported=!1,r;let n=t.document;const i=n,o=i.currentScript;t.DocumentFragment;const s=t.HTMLTemplateElement,a=t.Node,l=t.Element,c=t.NodeFilter;void 0===t.NamedNodeMap&&(t.NamedNodeMap||t.MozNamedAttrMap),t.HTMLFormElement;const u=t.DOMParser,p=t.trustedTypes,d=l.prototype,f=Xh(d,"cloneNode"),h=Xh(d,"remove"),m=Xh(d,"nextSibling"),g=Xh(d,"childNodes"),y=Xh(d,"parentNode"),b=Xh(d,"shadowRoot"),v=Xh(d,"attributes"),x=a&&a.prototype?Xh(a.prototype,"nodeType"):null,w=a&&a.prototype?Xh(a.prototype,"nodeName"):null;if("function"==typeof s){const e=n.createElement("template");e.content&&e.content.ownerDocument&&(n=e.content.ownerDocument)}let k,S="";const E=n,O=E.implementation,_=E.createNodeIterator,P=E.createDocumentFragment,$=E.getElementsByTagName,A=i.importNode;let C={afterSanitizeAttributes:[],afterSanitizeElements:[],afterSanitizeShadowDOM:[],beforeSanitizeAttributes:[],beforeSanitizeElements:[],beforeSanitizeShadowDOM:[],uponSanitizeAttribute:[],uponSanitizeElement:[],uponSanitizeShadowNode:[]};r.isSupported="function"==typeof mh&&"function"==typeof y&&O&&void 0!==O.createHTMLDocument;const j=cm,T=um,N=pm,I=dm,R=fm,L=mm,D=gm,M=bm;let z=hm,F=null;const B=Yh({},[...Jh,...Zh,...em,...rm,...im]);let U=null;const q=Yh({},[...om,...sm,...am,...lm]);let V=Object.seal(kh(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),W=null,H=null;const G=Object.seal(kh(null,{tagCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeCheck:{writable:!0,configurable:!1,enumerable:!0,value:null}}));let Y=!0,K=!0,Q=!1,X=!0,J=!1,Z=!0,ee=!1,te=!1,re=!1,ne=!1,ie=!1,oe=!1,se=!0,ae=!1;const le="user-content-";let ce=!0,ue=!1,pe={},de=null;const fe=Yh({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]);let he=null;const me=Yh({},["audio","video","img","source","image","track"]);let ge=null;const ye=Yh({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),be="http://www.w3.org/1998/Math/MathML",ve="http://www.w3.org/2000/svg",xe="http://www.w3.org/1999/xhtml";let we=xe,ke=!1,Se=null;const Ee=Yh({},[be,ve,xe],Nh);let Oe=Yh({},["mi","mo","mn","ms","mtext"]),_e=Yh({},["annotation-xml"]);const Pe=Yh({},["title","style","font","a","script"]);let $e=null;const Ae=["application/xhtml+xml","text/html"];let Ce=null,je=null;const Te=n.createElement("form"),Ne=function(e){return e instanceof RegExp||e instanceof Function},Ie=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(je&&je===e)return;e&&"object"==typeof e||(e={}),e=Qh(e),$e=-1===Ae.indexOf(e.PARSER_MEDIA_TYPE)?"text/html":e.PARSER_MEDIA_TYPE,Ce="application/xhtml+xml"===$e?Nh:Th,F=Uh(e,"ALLOWED_TAGS")&&jh(e.ALLOWED_TAGS)?Yh({},e.ALLOWED_TAGS,Ce):B,U=Uh(e,"ALLOWED_ATTR")&&jh(e.ALLOWED_ATTR)?Yh({},e.ALLOWED_ATTR,Ce):q,Se=Uh(e,"ALLOWED_NAMESPACES")&&jh(e.ALLOWED_NAMESPACES)?Yh({},e.ALLOWED_NAMESPACES,Nh):Ee,ge=Uh(e,"ADD_URI_SAFE_ATTR")&&jh(e.ADD_URI_SAFE_ATTR)?Yh(Qh(ye),e.ADD_URI_SAFE_ATTR,Ce):ye,he=Uh(e,"ADD_DATA_URI_TAGS")&&jh(e.ADD_DATA_URI_TAGS)?Yh(Qh(me),e.ADD_DATA_URI_TAGS,Ce):me,de=Uh(e,"FORBID_CONTENTS")&&jh(e.FORBID_CONTENTS)?Yh({},e.FORBID_CONTENTS,Ce):fe,W=Uh(e,"FORBID_TAGS")&&jh(e.FORBID_TAGS)?Yh({},e.FORBID_TAGS,Ce):Qh({}),H=Uh(e,"FORBID_ATTR")&&jh(e.FORBID_ATTR)?Yh({},e.FORBID_ATTR,Ce):Qh({}),pe=!!Uh(e,"USE_PROFILES")&&(e.USE_PROFILES&&"object"==typeof e.USE_PROFILES?Qh(e.USE_PROFILES):e.USE_PROFILES),Y=!1!==e.ALLOW_ARIA_ATTR,K=!1!==e.ALLOW_DATA_ATTR,Q=e.ALLOW_UNKNOWN_PROTOCOLS||!1,X=!1!==e.ALLOW_SELF_CLOSE_IN_ATTR,J=e.SAFE_FOR_TEMPLATES||!1,Z=!1!==e.SAFE_FOR_XML,ee=e.WHOLE_DOCUMENT||!1,ne=e.RETURN_DOM||!1,ie=e.RETURN_DOM_FRAGMENT||!1,oe=e.RETURN_TRUSTED_TYPE||!1,re=e.FORCE_BODY||!1,se=!1!==e.SANITIZE_DOM,ae=e.SANITIZE_NAMED_PROPS||!1,ce=!1!==e.KEEP_CONTENT,ue=e.IN_PLACE||!1,z=function(e){try{return Vh(e,""),!0}catch(e){return!1}}(e.ALLOWED_URI_REGEXP)?e.ALLOWED_URI_REGEXP:hm,we="string"==typeof e.NAMESPACE?e.NAMESPACE:xe,Oe=Uh(e,"MATHML_TEXT_INTEGRATION_POINTS")&&e.MATHML_TEXT_INTEGRATION_POINTS&&"object"==typeof e.MATHML_TEXT_INTEGRATION_POINTS?Qh(e.MATHML_TEXT_INTEGRATION_POINTS):Yh({},["mi","mo","mn","ms","mtext"]),_e=Uh(e,"HTML_INTEGRATION_POINTS")&&e.HTML_INTEGRATION_POINTS&&"object"==typeof e.HTML_INTEGRATION_POINTS?Qh(e.HTML_INTEGRATION_POINTS):Yh({},["annotation-xml"]);const t=Uh(e,"CUSTOM_ELEMENT_HANDLING")&&e.CUSTOM_ELEMENT_HANDLING&&"object"==typeof e.CUSTOM_ELEMENT_HANDLING?Qh(e.CUSTOM_ELEMENT_HANDLING):kh(null);if(V=kh(null),Uh(t,"tagNameCheck")&&Ne(t.tagNameCheck)&&(V.tagNameCheck=t.tagNameCheck),Uh(t,"attributeNameCheck")&&Ne(t.attributeNameCheck)&&(V.attributeNameCheck=t.attributeNameCheck),Uh(t,"allowCustomizedBuiltInElements")&&"boolean"==typeof t.allowCustomizedBuiltInElements&&(V.allowCustomizedBuiltInElements=t.allowCustomizedBuiltInElements),J&&(K=!1),ie&&(ne=!0),pe&&(F=Yh({},im),U=kh(null),!0===pe.html&&(Yh(F,Jh),Yh(U,om)),!0===pe.svg&&(Yh(F,Zh),Yh(U,sm),Yh(U,lm)),!0===pe.svgFilters&&(Yh(F,em),Yh(U,sm),Yh(U,lm)),!0===pe.mathMl&&(Yh(F,rm),Yh(U,am),Yh(U,lm))),G.tagCheck=null,G.attributeCheck=null,Uh(e,"ADD_TAGS")&&("function"==typeof e.ADD_TAGS?G.tagCheck=e.ADD_TAGS:jh(e.ADD_TAGS)&&(F===B&&(F=Qh(F)),Yh(F,e.ADD_TAGS,Ce))),Uh(e,"ADD_ATTR")&&("function"==typeof e.ADD_ATTR?G.attributeCheck=e.ADD_ATTR:jh(e.ADD_ATTR)&&(U===q&&(U=Qh(U)),Yh(U,e.ADD_ATTR,Ce))),Uh(e,"ADD_URI_SAFE_ATTR")&&jh(e.ADD_URI_SAFE_ATTR)&&Yh(ge,e.ADD_URI_SAFE_ATTR,Ce),Uh(e,"FORBID_CONTENTS")&&jh(e.FORBID_CONTENTS)&&(de===fe&&(de=Qh(de)),Yh(de,e.FORBID_CONTENTS,Ce)),Uh(e,"ADD_FORBID_CONTENTS")&&jh(e.ADD_FORBID_CONTENTS)&&(de===fe&&(de=Qh(de)),Yh(de,e.ADD_FORBID_CONTENTS,Ce)),ce&&(F["#text"]=!0),ee&&Yh(F,["html","head","body"]),F.table&&(Yh(F,["tbody"]),delete W.tbody),e.TRUSTED_TYPES_POLICY){if("function"!=typeof e.TRUSTED_TYPES_POLICY.createHTML)throw Wh('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if("function"!=typeof e.TRUSTED_TYPES_POLICY.createScriptURL)throw Wh('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');k=e.TRUSTED_TYPES_POLICY,S=k.createHTML("")}else void 0===k&&(k=function(e,t){if("object"!=typeof e||"function"!=typeof e.createPolicy)return null;let r=null;const n="data-tt-policy-suffix";t&&t.hasAttribute(n)&&(r=t.getAttribute(n));const i="dompurify"+(r?"#"+r:"");try{return e.createPolicy(i,{createHTML(e){return e},createScriptURL(e){return e}})}catch(e){return console.warn("TrustedTypes policy "+i+" could not be created."),null}}(p,o)),null!==k&&"string"==typeof S&&(S=k.createHTML(""));xh&&xh(e),je=e},Re=Yh({},[...Zh,...em,...tm]),Le=Yh({},[...rm,...nm]),De=function(e){Ah(r.removed,{element:e});try{y(e).removeChild(e)}catch(t){h(e)}},Me=function(e,t){try{Ah(r.removed,{attribute:t.getAttributeNode(e),from:t})}catch(e){Ah(r.removed,{attribute:null,from:t})}if(t.removeAttribute(e),"is"===e)if(ne||ie)try{De(t)}catch(e){}else try{t.setAttribute(e,"")}catch(e){}},ze=function(e){let t=null,r=null;if(re)e=""+e;else{const t=Ih(e,/^[\r\n\t ]+/);r=t&&t[0]}"application/xhtml+xml"===$e&&we===xe&&(e=''+e+"");const i=k?k.createHTML(e):e;if(we===xe)try{t=(new u).parseFromString(i,$e)}catch(e){}if(!t||!t.documentElement){t=O.createDocument(we,"template",null);try{t.documentElement.innerHTML=ke?S:i}catch(e){}}const o=t.body||t.documentElement;return e&&r&&o.insertBefore(n.createTextNode(r),o.childNodes[0]||null),we===xe?$.call(t,ee?"html":"body")[0]:ee?t.documentElement:o},Fe=function(e){return _.call(e.ownerDocument||e,e,c.SHOW_ELEMENT|c.SHOW_COMMENT|c.SHOW_TEXT|c.SHOW_PROCESSING_INSTRUCTION|c.SHOW_CDATA_SECTION,null)},Be=function(e){e.normalize();const t=_.call(e.ownerDocument||e,e,c.SHOW_TEXT|c.SHOW_COMMENT|c.SHOW_CDATA_SECTION|c.SHOW_PROCESSING_INSTRUCTION,null);let r=t.nextNode();for(;r;){let e=r.data;_h([j,T,N],t=>{e=Rh(e,t," ")}),r.data=e,r=t.nextNode()}},Ue=function(e){const t=w?w(e):null;return"string"==typeof t&&"form"===Ce(t)&&("string"!=typeof e.nodeName||"string"!=typeof e.textContent||"function"!=typeof e.removeChild||e.attributes!==v(e)||"function"!=typeof e.removeAttribute||"function"!=typeof e.setAttribute||"string"!=typeof e.namespaceURI||"function"!=typeof e.insertBefore||"function"!=typeof e.hasChildNodes||e.childNodes!==g(e))},qe=function(e){if(!x||"object"!=typeof e||null===e)return!1;try{return 11===x(e)}catch(e){return!1}},Ve=function(e){if(!x||"object"!=typeof e||null===e)return!1;try{return"number"==typeof x(e)}catch(e){return!1}};function We(e,t,n){_h(e,e=>{e.call(r,t,n,je)})}const He=function(e){let t=null;if(We(C.beforeSanitizeElements,e,null),Ue(e))return De(e),!0;const n=Ce(e.nodeName);if(We(C.uponSanitizeElement,e,{tagName:n,allowedTags:F}),Z&&e.hasChildNodes()&&!Ve(e.firstElementChild)&&Vh(/<[/\w!]/g,e.innerHTML)&&Vh(/<[/\w!]/g,e.textContent))return De(e),!0;if(Z&&e.namespaceURI===xe&&"style"===n&&Ve(e.firstElementChild))return De(e),!0;if(7===e.nodeType)return De(e),!0;if(Z&&8===e.nodeType&&Vh(/<[/\w]/g,e.data))return De(e),!0;if(W[n]||!(G.tagCheck instanceof Function&&G.tagCheck(n))&&!F[n]){if(!W[n]&&Ke(n)){if(V.tagNameCheck instanceof RegExp&&Vh(V.tagNameCheck,n))return!1;if(V.tagNameCheck instanceof Function&&V.tagNameCheck(n))return!1}if(ce&&!de[n]){const t=y(e)||e.parentNode,r=g(e)||e.childNodes;if(r&&t)for(let n=r.length-1;n>=0;--n){const i=f(r[n],!0);t.insertBefore(i,m(e))}}return De(e),!0}return 1===(x?x(e):e.nodeType)&&!function(e){let t=y(e);t&&t.tagName||(t={namespaceURI:we,tagName:"template"});const r=Th(e.tagName),n=Th(t.tagName);return!!Se[e.namespaceURI]&&(e.namespaceURI===ve?t.namespaceURI===xe?"svg"===r:t.namespaceURI===be?"svg"===r&&("annotation-xml"===n||Oe[n]):Boolean(Re[r]):e.namespaceURI===be?t.namespaceURI===xe?"math"===r:t.namespaceURI===ve?"math"===r&&_e[n]:Boolean(Le[r]):e.namespaceURI===xe?!(t.namespaceURI===ve&&!_e[n])&&!(t.namespaceURI===be&&!Oe[n])&&!Le[r]&&(Pe[r]||!Re[r]):!("application/xhtml+xml"!==$e||!Se[e.namespaceURI]))}(e)||("noscript"===n||"noembed"===n||"noframes"===n)&&Vh(/<\/no(script|embed|frames)/i,e.innerHTML)?(De(e),!0):(J&&3===e.nodeType&&(t=e.textContent,_h([j,T,N],e=>{t=Rh(t,e," ")}),e.textContent!==t&&(Ah(r.removed,{element:e.cloneNode()}),e.textContent=t)),We(C.afterSanitizeElements,e,null),!1)},Ge=function(e,t,r){if(H[t])return!1;if(se&&("id"===t||"name"===t)&&(r in n||r in Te))return!1;const i=U[t]||G.attributeCheck instanceof Function&&G.attributeCheck(t,e);if(K&&!H[t]&&Vh(I,t));else if(Y&&Vh(R,t));else if(!i||H[t]){if(!(Ke(e)&&(V.tagNameCheck instanceof RegExp&&Vh(V.tagNameCheck,e)||V.tagNameCheck instanceof Function&&V.tagNameCheck(e))&&(V.attributeNameCheck instanceof RegExp&&Vh(V.attributeNameCheck,t)||V.attributeNameCheck instanceof Function&&V.attributeNameCheck(t,e))||"is"===t&&V.allowCustomizedBuiltInElements&&(V.tagNameCheck instanceof RegExp&&Vh(V.tagNameCheck,r)||V.tagNameCheck instanceof Function&&V.tagNameCheck(r))))return!1}else if(ge[t]);else if(Vh(z,Rh(r,D,"")));else if("src"!==t&&"xlink:href"!==t&&"href"!==t||"script"===e||0!==Lh(r,"data:")||!he[e])if(Q&&!Vh(L,Rh(r,D,"")));else if(r)return!1;return!0},Ye=Yh({},["annotation-xml","color-profile","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","missing-glyph"]),Ke=function(e){return!Ye[Th(e)]&&Vh(M,e)},Qe=function(e){We(C.beforeSanitizeAttributes,e,null);const t=e.attributes;if(!t||Ue(e))return;const n={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:U,forceKeepAttr:void 0};let i=t.length;for(;i--;){const o=t[i],s=o.name,a=o.namespaceURI,l=o.value,c=Ce(s),u=l;let d="value"===s?u:Dh(u);if(n.attrName=c,n.attrValue=d,n.keepAttr=!0,n.forceKeepAttr=void 0,We(C.uponSanitizeAttribute,e,n),d=n.attrValue,!ae||"id"!==c&&"name"!==c||0===Lh(d,le)||(Me(s,e),d=le+d),Z&&Vh(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i,d)){Me(s,e);continue}if("attributename"===c&&Ih(d,"href")){Me(s,e);continue}if(n.forceKeepAttr)continue;if(!n.keepAttr){Me(s,e);continue}if(!X&&Vh(/\/>/i,d)){Me(s,e);continue}J&&_h([j,T,N],e=>{d=Rh(d,e," ")});const f=Ce(e.nodeName);if(Ge(f,c,d)){if(k&&"object"==typeof p&&"function"==typeof p.getAttributeType)if(a);else switch(p.getAttributeType(f,c)){case"TrustedHTML":d=k.createHTML(d);break;case"TrustedScriptURL":d=k.createScriptURL(d)}if(d!==u)try{a?e.setAttributeNS(a,s,d):e.setAttribute(s,d),Ue(e)?De(e):$h(r.removed)}catch(t){Me(s,e)}}else Me(s,e)}We(C.afterSanitizeAttributes,e,null)},Xe=function(e){let t=null;const r=Fe(e);for(We(C.beforeSanitizeShadowDOM,e,null);t=r.nextNode();)We(C.uponSanitizeShadowNode,t,null),He(t),Qe(t),qe(t.content)&&Xe(t.content);We(C.afterSanitizeShadowDOM,e,null)},Je=function(e){if(1===(x?x(e):e.nodeType)){const t=b?b(e):e.shadowRoot;qe(t)&&(Je(t),Xe(t))}const t=g?g(e):e.childNodes;if(!t)return;const r=[];_h(t,e=>{Ah(r,e)});for(const e of r)Je(e)};return r.sanitize=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=null,o=null,s=null,a=null;if(ke=!e,ke&&(e="\x3c!--\x3e"),"string"!=typeof e&&!Ve(e)&&"string"!=typeof(e=function(e){switch(typeof e){case"string":return e;case"number":return Mh(e);case"boolean":return zh(e);case"bigint":return Fh?Fh(e):"0";case"symbol":return Bh?Bh(e):"Symbol()";case"undefined":default:return qh(e);case"function":case"object":{if(null===e)return qh(e);const t=e,r=Xh(t,"toString");if("function"==typeof r){const e=r(t);return"string"==typeof e?e:qh(e)}return qh(e)}}}(e)))throw Wh("dirty is not a string, aborting");if(!r.isSupported)return e;if(te||Ie(t),r.removed=[],"string"==typeof e&&(ue=!1),ue){const t=w?w(e):e.nodeName;if("string"==typeof t){const e=Ce(t);if(!F[e]||W[e])throw Wh("root node is forbidden and cannot be sanitized in-place")}if(Ue(e))throw Wh("root node is clobbered and cannot be sanitized in-place");Je(e)}else if(Ve(e))n=ze("\x3c!----\x3e"),o=n.ownerDocument.importNode(e,!0),1===o.nodeType&&"BODY"===o.nodeName||"HTML"===o.nodeName?n=o:n.appendChild(o),Je(o);else{if(!ne&&!J&&!ee&&-1===e.indexOf("<"))return k&&oe?k.createHTML(e):e;if(n=ze(e),!n)return ne?null:oe?S:""}n&&re&&De(n.firstChild);const l=Fe(ue?e:n);for(;s=l.nextNode();)He(s),Qe(s),qe(s.content)&&Xe(s.content);if(ue)return J&&Be(e),e;if(ne){if(J&&Be(n),ie)for(a=P.call(n.ownerDocument);n.firstChild;)a.appendChild(n.firstChild);else a=n;return(U.shadowroot||U.shadowrootmode)&&(a=A.call(i,a,!0)),a}let c=ee?n.outerHTML:n.innerHTML;return ee&&F["!doctype"]&&n.ownerDocument&&n.ownerDocument.doctype&&n.ownerDocument.doctype.name&&Vh(ym,n.ownerDocument.doctype.name)&&(c="\n"+c),J&&_h([j,T,N],e=>{c=Rh(c,e," ")}),k&&oe?k.createHTML(c):c},r.setConfig=function(){Ie(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),te=!0},r.clearConfig=function(){je=null,te=!1},r.isValidAttribute=function(e,t,r){je||Ie({});const n=Ce(e),i=Ce(t);return Ge(n,i,r)},r.addHook=function(e,t){"function"==typeof t&&Ah(C[e],t)},r.removeHook=function(e,t){if(void 0!==t){const r=Ph(C[e],t);return-1===r?void 0:Ch(C[e],r,1)[0]}return $h(C[e])},r.removeHooks=function(e){C[e]=[]},r.removeAllHooks=function(){C={afterSanitizeAttributes:[],afterSanitizeElements:[],afterSanitizeShadowDOM:[],beforeSanitizeAttributes:[],beforeSanitizeElements:[],beforeSanitizeShadowDOM:[],uponSanitizeAttribute:[],uponSanitizeElement:[],uponSanitizeShadowNode:[]}},r}();const wm=ps` + a { + text-decoration: ${e=>e.theme.typography.links.textDecoration}; + color: ${e=>e.theme.typography.links.color}; + + &:visited { + color: ${e=>e.theme.typography.links.visited}; + } + + &:hover { + color: ${e=>e.theme.typography.links.hover}; + text-decoration: ${e=>e.theme.typography.links.hoverTextDecoration}; + } + } +`,km=gs(wd)` + font-family: ${e=>e.theme.typography.fontFamily}; + font-weight: ${e=>e.theme.typography.fontWeightRegular}; + line-height: ${e=>e.theme.typography.lineHeight}; + + p { + &:last-child { + margin-bottom: 0; + } + } + + ${({$compact:e})=>e&&"\n p:first-child {\n margin-top: 0;\n }\n p:last-child {\n margin-bottom: 0;\n }\n "} + + ${({$inline:e})=>e&&" p {\n display: inline-block;\n }"} + + h1 { + ${hp(1)}; + color: ${e=>e.theme.colors.primary.main}; + margin-top: 0; + } + + h2 { + ${hp(2)}; + color: ${e=>e.theme.colors.text.primary}; + } + + code { + color: ${({theme:e})=>e.typography.code.color}; + background-color: ${({theme:e})=>e.typography.code.backgroundColor}; + + font-family: ${e=>e.theme.typography.code.fontFamily}; + border-radius: 2px; + border: 1px solid rgba(38, 50, 56, 0.1); + padding: 0 ${({theme:e})=>e.spacing.unit}px; + font-size: ${e=>e.theme.typography.code.fontSize}; + font-weight: ${({theme:e})=>e.typography.code.fontWeight}; + + word-break: break-word; + } + + pre { + font-family: ${e=>e.theme.typography.code.fontFamily}; + white-space: ${({theme:e})=>e.typography.code.wrap?"pre-wrap":"pre"}; + background-color: ${({theme:e})=>e.codeBlock.backgroundColor}; + color: white; + padding: ${e=>4*e.theme.spacing.unit}px; + overflow-x: auto; + line-height: normal; + border-radius: 0; + border: 1px solid rgba(38, 50, 56, 0.1); + + code { + background-color: transparent; + color: white; + padding: 0; + + &:before, + &:after { + content: none; + } + } + } + + blockquote { + margin: 0; + margin-bottom: 1em; + padding: 0 15px; + color: #777; + border-left: 4px solid #ddd; + } + + img { + max-width: 100%; + box-sizing: content-box; + } + + ul, + ol { + padding-left: 2em; + margin: 0; + margin-bottom: 1em; + + ul, + ol { + margin-bottom: 0; + margin-top: 0; + } + } + + table { + display: block; + width: 100%; + overflow: auto; + word-break: normal; + word-break: keep-all; + border-collapse: collapse; + border-spacing: 0; + margin-top: 1.5em; + margin-bottom: 1.5em; + } + + table tr { + background-color: #fff; + border-top: 1px solid #ccc; + + &:nth-child(2n) { + background-color: ${({theme:e})=>e.schema.nestedBackground}; + } + } + + table th, + table td { + padding: 6px 13px; + border: 1px solid #ddd; + } + + table th { + text-align: left; + font-weight: bold; + } + + ${Ep(".share-link")}; + + ${wm} + + ${ys("Markdown")}; +`;var Sm=Object.defineProperty,Em=Object.defineProperties,Om=Object.getOwnPropertyDescriptors,_m=Object.getOwnPropertySymbols,Pm=Object.prototype.hasOwnProperty,$m=Object.prototype.propertyIsEnumerable,Am=(e,t,r)=>t in e?Sm(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;const Cm=xm,jm=cs(km)` + display: inline; +`,Tm=(e,t)=>e?Cm.sanitize(t):t;function Nm(e){var t=e,{inline:n,compact:i}=t,o=((e,t)=>{var r={};for(var n in e)Pm.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&_m)for(var n of _m(e))t.indexOf(n)<0&&$m.call(e,n)&&(r[n]=e[n]);return r})(t,["inline","compact"]);const s=n?jm:km;return r.createElement(Ps,null,e=>r.createElement(s,((e,t)=>Em(e,Om(t)))(((e,t)=>{for(var r in t||(t={}))Pm.call(t,r)&&Am(e,r,t[r]);if(_m)for(var r of _m(t))$m.call(t,r)&&Am(e,r,t[r]);return e})({className:"redoc-markdown "+(o.className||""),dangerouslySetInnerHTML:{__html:Tm(e.sanitize,o.html)},"data-role":o["data-role"]},o),{$inline:n,$compact:i})))}class Im extends r.Component{render(){const{source:e,inline:t,compact:n,className:i,"data-role":o}=this.props,s=new Ll;return r.createElement(Nm,{html:s.renderMd(e),inline:t,compact:n,className:i,"data-role":o})}}const Rm=gs.div` + position: relative; +`,Lm=gs.div` + position: absolute; + min-width: 80px; + max-width: 500px; + background: #fff; + bottom: 100%; + left: 50%; + margin-bottom: 10px; + transform: translateX(-50%); + + border-radius: 4px; + padding: 0.3em 0.6em; + text-align: center; + box-shadow: 0px 0px 5px 0px rgba(204, 204, 204, 1); +`,Dm=gs.div` + background: #fff; + color: #000; + display: inline; + font-size: 0.85em; + white-space: nowrap; +`,Mm=gs.div` + position: absolute; + width: 0; + height: 0; + bottom: -5px; + left: 50%; + margin-left: -5px; + border-left: solid transparent 5px; + border-right: solid transparent 5px; + border-top: solid #fff 5px; +`,zm=gs.div` + position: absolute; + width: 100%; + height: 20px; + bottom: -20px; +`;class Fm extends r.Component{render(){const{open:e,title:t,children:n}=this.props;return r.createElement(Rm,null,n,e&&r.createElement(Lm,null,r.createElement(Dm,null,t),r.createElement(Mm,null),r.createElement(zm,null)))}}const Bm="undefined"!=typeof document&&document.queryCommandSupported&&document.queryCommandSupported("copy");class Um{static isSupported(){return Bm}static selectElement(e){let t,r;document.body.createTextRange?(t=document.body.createTextRange(),t.moveToElementText(e),t.select()):document.createRange&&window.getSelection&&(r=window.getSelection(),t=document.createRange(),t.selectNodeContents(e),r.removeAllRanges(),r.addRange(t))}static deselect(){if(document.selection)document.selection.empty();else if(window.getSelection){const e=window.getSelection();e&&e.removeAllRanges()}}static copySelected(){let e;try{e=document.execCommand("copy")}catch(t){e=!1}return e}static copyElement(e){Um.selectElement(e);const t=Um.copySelected();return t&&Um.deselect(),t}static copyCustom(e){const t=document.createElement("textarea");t.style.position="fixed",t.style.top="0",t.style.left="0",t.style.width="2em",t.style.height="2em",t.style.padding="0",t.style.border="none",t.style.outline="none",t.style.boxShadow="none",t.style.background="transparent",t.value=e,document.body.appendChild(t),t.select();const r=Um.copySelected();return document.body.removeChild(t),r}}const qm=e=>{const[t,n]=r.useState(!1),i=()=>{const t="string"==typeof e.data?e.data:JSON.stringify(e.data,null,2);Um.copyCustom(t),o()},o=()=>{n(!0),setTimeout(()=>{n(!1)},1500)};return e.children({renderCopyButton:()=>r.createElement("button",{onClick:i},r.createElement(Fm,{title:Um.isSupported()?"Copied":"Not supported in your browser",open:t},"Copy"))})};let Vm=1;function Wm(e,t){Vm=1;let r="";return r+='
    ',r+="",r+=Qm(e,t),r+="",r+="
    ",r}function Hm(e){return void 0!==e?e.toString().replace(/&/g,"&").replace(/"/g,""").replace(//g,">"):""}function Gm(e){return JSON.stringify(e).slice(1,-1)}function Ym(e,t){return''+Hm(e)+""}function Km(e){return''+e+""}function Qm(e,t){const r=typeof e;let n="";return null==e?n+=Ym("null","token keyword"):e&&e.constructor===Array?(Vm++,n+=function(e,t){const r=Vm>t?"collapsed":"";let n=`${Km("[")}
      `,i=!1;const o=e.length;for(let s=0;s
      ',n+=Qm(e[s],t),s";return n+=`
    ${Km("]")}`,i||(n=Km("[ ]")),n}(e,t),Vm--):e&&e.constructor===Date?n+=Ym('"'+e.toISOString()+'"',"token string"):"object"===r?(Vm++,n+=function(e,t){const r=Vm>t?"collapsed":"",n=Object.keys(e),i=n.length;let o=`${Km("{")}
      `,s=!1;for(let a=0;a
      ',o+='"'+Hm(l)+'": ',o+=Qm(e[l],t),a"}return o+=`
    ${Km("}")}`,s||(o=Km("{ }")),o}(e,t),Vm--):"number"===r?n+=Ym(e,"token number"):"string"===r?/^(http|https):\/\/[^\s]+$/.test(e)?n+=Ym('"',"token string")+'    '+Hm(Gm(e))+""+Ym('"',"token string"):n+=Ym('"'+Gm(e)+'"',"token string"):"boolean"===r&&(n+=Ym(e,"token boolean")),n}const Xm=ps` + .redoc-json code > .collapser { + display: none; + pointer-events: none; + } + + font-family: ${e=>e.theme.typography.code.fontFamily}; + font-size: ${e=>e.theme.typography.code.fontSize}; + + white-space: ${({theme:e})=>e.typography.code.wrap?"pre-wrap":"pre"}; + contain: content; + overflow-x: auto; + + .callback-function { + color: gray; + } + + .collapser:after { + content: '-'; + cursor: pointer; + } + + .collapsed > .collapser:after { + content: '+'; + cursor: pointer; + } + + .ellipsis:after { + content: ' … '; + } + + .collapsible { + margin-left: 2em; + } + + .hoverable { + padding-top: 1px; + padding-bottom: 1px; + padding-left: 2px; + padding-right: 2px; + border-radius: 2px; + } + + .hovered { + background-color: rgba(235, 238, 249, 1); + } + + .collapser { + background-color: transparent; + border: 0; + color: #fff; + font-family: ${e=>e.theme.typography.code.fontFamily}; + font-size: ${e=>e.theme.typography.code.fontSize}; + padding-right: 6px; + padding-left: 6px; + padding-top: 0; + padding-bottom: 0; + display: flex; + align-items: center; + justify-content: center; + width: 15px; + height: 15px; + position: absolute; + top: 4px; + left: -1.5em; + cursor: default; + user-select: none; + -webkit-user-select: none; + padding: 2px; + &:focus { + outline-color: #fff; + outline-style: dotted; + outline-width: 1px; + } + } + + ul { + list-style-type: none; + padding: 0px; + margin: 0px 0px 0px 26px; + } + + li { + position: relative; + display: block; + } + + .hoverable { + display: inline-block; + } + + .selected { + outline-style: solid; + outline-width: 1px; + outline-style: dotted; + } + + .collapsed > .collapsible { + display: none; + } + + .ellipsis { + display: none; + } + + .collapsed > .ellipsis { + display: inherit; + } +`,Jm=gs.div` + &:hover > ${kd} { + opacity: 1; + } +`,Zm=gs(e=>{const[t,n]=r.useState(),i=({renderCopyButton:t})=>{const i=e.data&&Object.values(e.data).some(e=>"object"==typeof e&&null!==e);return r.createElement(Jm,null,r.createElement(kd,null,t(),i&&r.createElement(r.Fragment,null,r.createElement("button",{onClick:o}," Expand all "),r.createElement("button",{onClick:s}," Collapse all "))),r.createElement(Os.Consumer,null,t=>r.createElement(wd,{tabIndex:0,className:e.className,ref:e=>n(e),dangerouslySetInnerHTML:{__html:Wm(e.data,t.jsonSamplesExpandLevel)}})))},o=()=>{const e=null==t?void 0:t.getElementsByClassName("collapsible");for(const t of Array.prototype.slice.call(e)){const e=t.parentNode;e.classList.remove("collapsed"),e.querySelector(".collapser").setAttribute("aria-label","collapse")}},s=()=>{const e=null==t?void 0:t.getElementsByClassName("collapsible"),r=Array.prototype.slice.call(e,1);for(const e of r){const t=e.parentNode;t.classList.add("collapsed"),t.querySelector(".collapser").setAttribute("aria-label","expand")}},a=e=>{let t;"collapser"===e.className&&(t=e.parentElement.getElementsByClassName("collapsible")[0],t.parentElement.classList.contains("collapsed")?(t.parentElement.classList.remove("collapsed"),e.setAttribute("aria-label","collapse")):(t.parentElement.classList.add("collapsed"),e.setAttribute("aria-label","expand")))},l=r.useCallback(e=>{a(e.target)},[]),c=r.useCallback(e=>{"Enter"===e.key&&a(e.target)},[]);return r.useEffect(()=>(null==t||t.addEventListener("click",l),null==t||t.addEventListener("focus",c),()=>{null==t||t.removeEventListener("click",l),null==t||t.removeEventListener("focus",c)}),[l,c,t]),r.createElement(qm,{data:e.data},i)})` + ${Xm}; +`,eg=e=>{const{source:t,lang:n}=e;return r.createElement(Ed,{dangerouslySetInnerHTML:{__html:ka(t,n)}})},tg=e=>{const{source:t,lang:n}=e;return r.createElement(qm,{data:t},({renderCopyButton:e})=>r.createElement(Sd,null,r.createElement(kd,null,e()),r.createElement(eg,{lang:n,source:t})))};function rg({value:e,mimeType:t}){return ea(t)?r.createElement(Zm,{data:e}):("object"==typeof e&&(e=JSON.stringify(e,null,2)),r.createElement(tg,{lang:(n=t,-1!==n.search(/xml/i)?"xml":-1!==n.search(/csv/i)?"csv":-1!==n.search(/plain/i)?"tex":"clike"),source:e}));var n}function ng({example:e,mimeType:t}){return void 0===e.value&&e.externalValueUrl?r.createElement(ig,{example:e,mimeType:t}):r.createElement(rg,{value:e.value,mimeType:t})}function ig({example:e,mimeType:t}){const n=function(e,t){const[,n]=(0,r.useState)(!0),i=(0,r.useRef)(void 0),o=(0,r.useRef)(void 0);return o.current!==e&&(i.current=void 0),o.current=e,(0,r.useEffect)(()=>{(()=>{return r=this,o=function*(){n(!0);try{i.current=yield e.getExternalValue(t)}catch(e){i.current=e}n(!1)},new Promise((e,t)=>{var n=e=>{try{s(o.next(e))}catch(e){t(e)}},i=e=>{try{s(o.throw(e))}catch(e){t(e)}},s=t=>t.done?e(t.value):Promise.resolve(t.value).then(n,i);s((o=o.apply(r,null)).next())});var r,o})()},[e,t]),i.current}(e,t);return void 0===n?r.createElement("span",null,"Loading..."):n instanceof Error?r.createElement(Ed,null,"Error loading external example: ",r.createElement("br",null),r.createElement("a",{className:"token string",href:e.externalValueUrl,target:"_blank",rel:"noopener noreferrer"},e.externalValueUrl)):r.createElement(rg,{value:n,mimeType:t})}const og=gs.div` + padding: 0.9em; + background-color: ${({theme:e})=>Gn(.6,e.rightPanel.backgroundColor)}; + margin: 0 0 10px 0; + display: block; + font-family: ${({theme:e})=>e.typography.headings.fontFamily}; + font-size: 0.929em; + line-height: 1.5em; +`,sg=gs.span` + font-family: ${({theme:e})=>e.typography.headings.fontFamily}; + font-size: 12px; + position: absolute; + z-index: 1; + top: -11px; + left: 12px; + font-weight: ${({theme:e})=>e.typography.fontWeightBold}; + color: ${({theme:e})=>Gn(.3,e.rightPanel.textColor)}; +`,ag=gs.div` + position: relative; +`,lg=gs(mf)` + label { + color: ${({theme:e})=>e.rightPanel.textColor}; + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; + font-size: 1em; + text-transform: none; + border: none; + } + margin: 0 0 10px 0; + display: block; + background-color: ${({theme:e})=>Gn(.6,e.rightPanel.backgroundColor)}; + border: none; + padding: 0.9em 1.6em 0.9em 0.9em; + box-shadow: none; + &:hover, + &:focus-within { + border: none; + box-shadow: none; + background-color: ${({theme:e})=>Gn(.3,e.rightPanel.backgroundColor)}; + } +`,cg=gs.div` + font-family: ${e=>e.theme.typography.code.fontFamily}; + font-size: 12px; + color: #ee807f; +`;class ug extends r.Component{constructor(){super(...arguments),this.state={activeIdx:0},this.switchMedia=({idx:e})=>{void 0!==e&&this.setState({activeIdx:e})}}render(){const{activeIdx:e}=this.state,t=this.props.mediaType.examples||{},n=this.props.mediaType.name,i=r.createElement(cg,null,"No sample"),o=Object.keys(t);if(0===o.length)return i;if(o.length>1){const i=o.map((e,r)=>({value:t[e].summary||e,idx:r})),s=t[o[e]],a=s.description;return r.createElement(pg,null,r.createElement(ag,null,r.createElement(sg,null,"Example"),this.props.renderDropdown({value:i[e].value,options:i,onChange:this.switchMedia,ariaLabel:"Example"})),r.createElement("div",null,a&&r.createElement(Im,{source:a}),r.createElement(ng,{example:s,mimeType:n})))}{const e=t[o[0]];return r.createElement(pg,null,e.description&&r.createElement(Im,{source:e.description}),r.createElement(ng,{example:e,mimeType:n}))}}}const pg=gs.div` + margin-top: 15px; +`;if(!r.useState)throw new Error("mobx-react-lite requires React with Hooks support");if(!ir)throw new Error("mobx-react-lite@3 requires mobx at least version 6 to be available");var dg=n(961);function fg(e){e()}function hg(e){return Ft(Yr(e,t));var t}var mg,gg,yg=function(){function e(e){var t=this;Object.defineProperty(this,"finalize",{enumerable:!0,configurable:!0,writable:!0,value:e}),Object.defineProperty(this,"registrations",{enumerable:!0,configurable:!0,writable:!0,value:new Map}),Object.defineProperty(this,"sweepTimeout",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"sweep",{enumerable:!0,configurable:!0,writable:!0,value:function(e){void 0===e&&(e=1e4),clearTimeout(t.sweepTimeout),t.sweepTimeout=void 0;var r=Date.now();t.registrations.forEach(function(n,i){r-n.registeredAt>=e&&(t.finalize(n.value),t.registrations.delete(i))}),t.registrations.size>0&&t.scheduleSweep()}}),Object.defineProperty(this,"finalizeAllImmediately",{enumerable:!0,configurable:!0,writable:!0,value:function(){t.sweep(0)}})}return Object.defineProperty(e.prototype,"register",{enumerable:!1,configurable:!0,writable:!0,value:function(e,t,r){this.registrations.set(r,{value:t,registeredAt:Date.now()}),this.scheduleSweep()}}),Object.defineProperty(e.prototype,"unregister",{enumerable:!1,configurable:!0,writable:!0,value:function(e){this.registrations.delete(e)}}),Object.defineProperty(e.prototype,"scheduleSweep",{enumerable:!1,configurable:!0,writable:!0,value:function(){void 0===this.sweepTimeout&&(this.sweepTimeout=setTimeout(this.sweep,1e4))}}),e}(),bg=new("undefined"!=typeof FinalizationRegistry?FinalizationRegistry:yg)(function(e){var t;null===(t=e.reaction)||void 0===t||t.dispose(),e.reaction=null}),vg=n(9888);function xg(e){e.reaction=new yt("observer".concat(e.name),function(){var t;e.stateVersion=Symbol(),null===(t=e.onStoreChange)||void 0===t||t.call(e)})}var wg="function"==typeof Symbol&&Symbol.for,kg=null!==(gg=null===(mg=Object.getOwnPropertyDescriptor(function(){},"name"))||void 0===mg?void 0:mg.configurable)&&void 0!==gg&&gg,Sg=wg?Symbol.for("react.forward_ref"):"function"==typeof r.forwardRef&&(0,r.forwardRef)(function(e){return null}).$$typeof,Eg=wg?Symbol.for("react.memo"):"function"==typeof r.memo&&(0,r.memo)(function(e){return null}).$$typeof;function Og(e,t){var n;if(Eg&&e.$$typeof===Eg)throw new Error("[mobx-react-lite] You are trying to use `observer` on a function component wrapped in either another `observer` or `React.memo`. The observer already applies 'React.memo' for you.");var i=null!==(n=null==t?void 0:t.forwardRef)&&void 0!==n&&n,o=e,s=e.displayName||e.name;if(Sg&&e.$$typeof===Sg&&(i=!0,"function"!=typeof(o=e.render)))throw new Error("[mobx-react-lite] `render` property of ForwardRef was not a function");var a,l,c=function(e,t){return function(e,t){void 0===t&&(t="observed");var n=r.useRef(null);if(!n.current){var i={reaction:null,onStoreChange:null,stateVersion:Symbol(),name:t,subscribe:function(e){return bg.unregister(i),i.onStoreChange=e,i.reaction||(xg(i),i.stateVersion=Symbol()),function(){var e;i.onStoreChange=null,null===(e=i.reaction)||void 0===e||e.dispose(),i.reaction=null}},getSnapshot:function(){return i.stateVersion}};n.current=i}var o,s,a=n.current;if(a.reaction||(xg(a),bg.register(n,a,a)),r.useDebugValue(a.reaction,hg),(0,vg.useSyncExternalStore)(a.subscribe,a.getSnapshot,a.getSnapshot),a.reaction.track(function(){try{o=e()}catch(e){s=e}}),s)throw s;return o}(function(){return o(e,t)},s)};return c.displayName=e.displayName,kg&&Object.defineProperty(c,"name",{value:e.name,writable:!0,configurable:!0}),e.contextTypes&&(c.contextTypes=e.contextTypes),i&&(c=(0,r.forwardRef)(c)),c=(0,r.memo)(c),a=e,l=c,Object.keys(a).forEach(function(e){_g[e]||Object.defineProperty(l,e,Object.getOwnPropertyDescriptor(a,e))}),c}var _g={$$typeof:!0,render:!0,compare:!0,type:!0,displayName:!0};function Pg(e,t){return e===t?0!==e||1/e==1/t:e!=e&&t!=t}!function(e){e||(e=fg),zt({reactionScheduler:e})}(dg.unstable_batchedUpdates),bg.finalizeAllImmediately;var $g=Symbol("patchMixins"),Ag=Symbol("patchedDefinition");function Cg(e,t){for(var r=this,n=arguments.length,i=new Array(n>2?n-2:0),o=2;o"}function Mg(e){var t=e.bind(this),r=Lg(this);return function(){r.reaction||(r.reaction=function(e){return new yt(e.name+".render()",function(){if(e.mounted)try{null==e.forceUpdate||e.forceUpdate()}catch(r){var t;null==(t=e.reaction)||t.dispose(),e.reaction=null}else e.reactionInvalidatedBeforeMount=!0})}(r),r.mounted||bg.register(this,r,this));var e=void 0,n=void 0;if(r.reaction.track(function(){try{n=function(e,t){var r=Be(e);try{return t()}finally{Ue(r)}}(!1,t)}catch(t){e=t}}),e)throw e;return n}}function zg(e,t){return this.state!==t||!function(e,t){if(Pg(e,t))return!0;if("object"!=typeof e||null===e||"object"!=typeof t||null===t)return!1;var r=Object.keys(e),n=Object.keys(t);if(r.length!==n.length)return!1;for(var i=0;i {}` or `render = function() {}` is not supported.")}t.render=function(){return Object.defineProperty(this,"render",{configurable:!1,writable:!1,value:Mg.call(this,i)}),this.render()};var s=t.componentDidMount;return t.componentDidMount=function(){var e=this,t=Lg(this);return t.mounted=!0,bg.unregister(this),t.forceUpdate=function(){return e.forceUpdate()},t.reaction&&!t.reactionInvalidatedBeforeMount||t.forceUpdate(),null==s?void 0:s.apply(this,arguments)},Tg(t,"componentWillUnmount",function(){var e,t=Lg(this);null==(e=t.reaction)||e.dispose(),t.reaction=null,t.forceUpdate=null,t.mounted=!1,t.reactionInvalidatedBeforeMount=!1}),e}(e):Og(e)}if(r.version.split(".")[0],!r.Component)throw new Error("mobx-react requires React to be available");if(!Ce)throw new Error("mobx-react requires mobx to be available");const Bg=gs(Ip)` + &.deprecated { + span.property-name { + ${Cp} + } + } + + button { + background-color: transparent; + border: 0; + outline: 0; + font-size: 13px; + font-family: ${e=>e.theme.typography.code.fontFamily}; + cursor: pointer; + padding: 0; + color: ${e=>e.theme.colors.text.primary}; + &:focus { + font-weight: ${({theme:e})=>e.typography.fontWeightBold}; + } + ${({kind:e})=>"patternProperties"===e&&ps` + display: inline-flex; + margin-right: 20px; + + > span.property-name { + white-space: break-spaces; + text-align: left; + + ::before, + ::after { + content: '/'; + filter: opacity(0.2); + } + } + + > svg { + align-self: center; + } + `} + } + ${$p} { + height: ${({theme:e})=>e.schema.arrow.size}; + width: ${({theme:e})=>e.schema.arrow.size}; + polygon { + fill: ${({theme:e})=>e.schema.arrow.color}; + } + } +`,Ug=gs.span` + vertical-align: middle; + font-size: ${({theme:e})=>e.typography.code.fontSize}; + line-height: 20px; +`,qg=gs(Ug)` + color: ${e=>Gn(.1,e.theme.schema.typeNameColor)}; +`,Vg=gs(Ug)` + color: ${e=>e.theme.schema.typeNameColor}; +`,Wg=gs(Ug)` + color: ${e=>e.theme.schema.typeTitleColor}; + word-break: break-word; +`,Hg=Vg,Gg=gs(Ug).attrs({as:"div"})` + color: ${e=>e.theme.schema.requireLabelColor}; + font-size: ${e=>e.theme.schema.labelsTextSize}; + font-weight: normal; + margin-left: 20px; + line-height: 1; +`,Yg=gs(Gg)` + color: ${e=>e.theme.colors.primary.light}; +`,Kg=gs(Ug)` + color: ${({theme:e})=>e.colors.warning.main}; + font-size: 13px; +`,Qg=gs(Ug)` + color: #0e7c86; + font-family: ${e=>e.theme.typography.code.fontFamily}; + font-size: 12px; + &::before, + &::after { + content: ' '; + } +`,Xg=gs(Ug)` + border-radius: 2px; + word-break: break-word; + ${({theme:e})=>`\n background-color: ${Gn(.95,e.colors.text.primary)};\n color: ${Gn(.1,e.colors.text.primary)};\n\n padding: 0 ${e.spacing.unit}px;\n border: 1px solid ${Gn(.9,e.colors.text.primary)};\n font-family: ${e.typography.code.fontFamily};\n}`}; + & + & { + margin-left: 0; + } + ${ys("ExampleValue")}; +`,Jg=gs(Xg)``,Zg=gs(Ug)` + border-radius: 2px; + ${({theme:e})=>`\n background-color: ${Gn(.95,e.colors.primary.light)};\n color: ${Gn(.1,e.colors.primary.main)};\n\n margin: 0 ${e.spacing.unit}px;\n padding: 0 ${e.spacing.unit}px;\n border: 1px solid ${Gn(.9,e.colors.primary.main)};\n}`}; + & + & { + margin-left: 0; + } + ${ys("ConstraintItem")}; +`,ey=gs.button` + background-color: transparent; + border: 0; + color: ${({theme:e})=>e.colors.text.secondary}; + margin-left: ${({theme:e})=>e.spacing.unit}px; + border-radius: 2px; + cursor: pointer; + outline-color: ${({theme:e})=>e.colors.text.secondary}; + font-size: 12px; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;const ty=gs.div` + ${wm}; + ${({$compact:e})=>e?"":"margin: 1em 0"} +`;let ry=class extends r.Component{render(){const{externalDocs:e}=this.props;return e&&e.url?r.createElement(ty,{$compact:this.props.compact},r.createElement("a",{href:e.url},e.description||e.url)):null}};ry=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],ry);const ny=gs(km)` + table { + margin-bottom: 0.2em; + } +`;class iy extends r.PureComponent{constructor(e){super(e),this.state={collapsed:!0},this.toggle=this.toggle.bind(this)}toggle(){this.setState({collapsed:!this.state.collapsed})}render(){const{values:e,type:t}=this.props,{collapsed:n}=this.state,i=!Array.isArray(e),o=Array.isArray(e)&&e||Object.entries(e||{}).map(([e,t])=>({value:e,description:t})),{enumSkipQuotes:s,maxDisplayedEnumValues:a}=this.context;if(!o.length)return null;const l=this.state.collapsed&&a?o.slice(0,a):o,c=!!a&&o.length>a,u=a?n?`… ${o.length-a} more`:"Hide":"";return r.createElement("div",null,i?r.createElement(r.Fragment,null,r.createElement(ny,null,r.createElement("table",null,r.createElement("thead",null,r.createElement("tr",null,r.createElement("th",null,r.createElement(Ug,null,"array"===t?hi("enumArray"):""," ",1===o.length?hi("enumSingleValue"):hi("enum"))," "),r.createElement("th",null,r.createElement("strong",null,"Description")))),r.createElement("tbody",null,l.map(({description:e,value:t})=>r.createElement("tr",{key:t},r.createElement("td",null,t),r.createElement("td",null,r.createElement(Im,{source:e,compact:!0,inline:!0}))))))),c?r.createElement(oy,{onClick:this.toggle},u):null):r.createElement(r.Fragment,null,r.createElement(Ug,null,"array"===t?hi("enumArray"):""," ",1===e.length?hi("enumSingleValue"):hi("enum"),":")," ",l.map((e,t)=>{const n=s?String(e):JSON.stringify(e);return r.createElement(r.Fragment,{key:t},r.createElement(Xg,null,n)," ")}),c?r.createElement(oy,{onClick:this.toggle},u):null))}}iy.contextType=Os;const oy=gs.span` + color: ${e=>e.theme.colors.primary.main}; + vertical-align: middle; + font-size: 13px; + line-height: 20px; + padding: 0 5px; + cursor: pointer; +`,sy=gs(km)` + margin: 2px 0; +`;class ay extends r.PureComponent{render(){const e=this.props.extensions;return r.createElement(Os.Consumer,null,t=>r.createElement(r.Fragment,null,t.showExtensions&&Object.keys(e).map(t=>r.createElement(sy,{key:t},r.createElement(Ug,null," ",t.substring(2),": ")," ",r.createElement(Jg,null,"string"==typeof e[t]?e[t]:JSON.stringify(e[t]))))))}}function ly({field:e}){return e.examples?r.createElement(r.Fragment,null,r.createElement(Ug,null," ",hi("examples"),": "),pi(e.examples)?e.examples.map((t,n)=>{const i=oa(e,t),o=e.in?String(i):JSON.stringify(i);return r.createElement(r.Fragment,{key:n},r.createElement(Xg,null,o)," ")}):r.createElement(cy,null,Object.values(e.examples).map((t,n)=>r.createElement("li",{key:n+t.value},r.createElement(Xg,null,oa(e,t.value))," -"," ",t.summary||t.description)))):null}const cy=gs.ul` + margin-top: 1em; + list-style-position: outside; +`;class uy extends r.PureComponent{render(){return 0===this.props.constraints.length?null:r.createElement("span",null," ",this.props.constraints.map(e=>r.createElement(Zg,{key:e}," ",e," ")))}}const py=r.memo(function({value:e,label:t,raw:n}){if(void 0===e)return null;const i=n?String(e):JSON.stringify(e);return r.createElement("div",null,r.createElement(Ug,null," ",t," ")," ",r.createElement(Xg,null,i))});function dy(e){const t=e.schema.pattern,{hideSchemaPattern:n}=r.useContext(Os),[i,o]=r.useState(!1),s=r.useCallback(()=>o(!i),[i]);return!t||n?null:r.createElement(r.Fragment,null,r.createElement(Qg,null,i||t.length<45?t:`${t.substr(0,45)}...`),t.length>45&&r.createElement(ey,{onClick:s},i?"Hide pattern":"Show pattern"))}function fy({schema:e}){var t;const{hideSchemaPattern:n}=r.useContext(Os);return e&&((null==e?void 0:e.pattern)&&!n||e.items||e.displayFormat||(null==(t=e.constraints)?void 0:t.length))?r.createElement(hy,null,"[ items",e.displayFormat&&r.createElement(Hg,null," <",e.displayFormat," >"),r.createElement(uy,{constraints:e.constraints}),r.createElement(dy,{schema:e}),e.items&&r.createElement(fy,{schema:e.items})," ]"):null}const hy=gs(qg)` + margin: 0 5px; + vertical-align: text-top; +`;var my=Object.defineProperty,gy=Object.getOwnPropertySymbols,yy=Object.prototype.hasOwnProperty,by=Object.prototype.propertyIsEnumerable,vy=(e,t,r)=>t in e?my(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,xy=(e,t)=>{for(var r in t||(t={}))yy.call(t,r)&&vy(e,r,t[r]);if(gy)for(var r of gy(t))by.call(t,r)&&vy(e,r,t[r]);return e};const wy=Fg(e=>{const{enumSkipQuotes:t,hideSchemaTitles:n}=r.useContext(Os),{showExamples:i,field:o,renderDiscriminatorSwitch:s}=e,{schema:a,description:l,deprecated:c,extensions:u,in:p,const:d}=o,f="array"===a.type||pi(a.type)&&a.type.includes("array"),h=t||"header"===p,m=r.useMemo(()=>!i||void 0===o.example&&void 0===o.examples?null:void 0!==o.examples?r.createElement(ly,{field:o}):r.createElement(py,{label:hi("example")+":",value:oa(o,o.example),raw:Boolean(o.in)}),[o,i]),g=si(a.default)&&o.in?oa(o,a.default).replace(`${o.name}=`,""):a.default;return r.createElement("div",null,r.createElement("div",null,r.createElement(qg,null,a.typePrefix),r.createElement(Vg,null,a.displayType),a.displayFormat&&r.createElement(Hg,null," ","<",a.displayFormat,">"," "),a.contentEncoding&&r.createElement(Hg,null," ","<",a.contentEncoding,">"," "),a.contentMediaType&&r.createElement(Hg,null," ","<",a.contentMediaType,">"," "),a.title&&!n&&r.createElement(Wg,null," (",a.title,") "),r.createElement(uy,{constraints:a.constraints}),r.createElement(dy,{schema:a}),a.isCircular&&r.createElement(Kg,null," ",hi("recursive")," "),f&&a.items&&r.createElement(fy,{schema:a.items})),c&&r.createElement("div",null,r.createElement(Ap,{type:"warning"}," ",hi("deprecated")," ")),r.createElement(py,{raw:h,label:hi("default")+":",value:g}),!s&&r.createElement(iy,{type:a.type,values:a["x-enumDescriptions"]||a.enum})," ",m,r.createElement(ay,{extensions:xy(xy({},u),a.extensions)}),r.createElement("div",null,r.createElement(Im,{compact:!0,source:l})),a.externalDocs&&r.createElement(ry,{externalDocs:a.externalDocs,compact:!0}),s&&s(e)||null,d&&r.createElement(py,{label:hi("const")+":",value:d})||null)}),ky=r.memo(wy);var Sy=Object.defineProperty,Ey=(Object.getOwnPropertyDescriptor,Object.getOwnPropertySymbols),Oy=Object.prototype.hasOwnProperty,_y=Object.prototype.propertyIsEnumerable,Py=(e,t,r)=>t in e?Sy(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;let $y=class extends r.Component{constructor(){super(...arguments),this.toggle=()=>{void 0===this.props.field.expanded&&this.props.expandByDefault?this.props.field.collapse():this.props.field.toggle()},this.handleKeyPress=e=>{"Enter"===e.key&&(e.preventDefault(),this.toggle())}}render(){const{hidePropertiesPrefix:e}=this.context,{className:t="",field:n,isLast:i,expandByDefault:o,fieldParentsName:s=[]}=this.props,{name:a,deprecated:l,required:c,kind:u}=n,p=!n.schema.isPrimitive&&!n.schema.isCircular,d=void 0===n.expanded?o:n.expanded,f=r.createElement(r.Fragment,null,"additionalProperties"===u&&r.createElement(Yg,null,"additional property"),"patternProperties"===u&&r.createElement(Yg,null,"pattern property"),c&&r.createElement(Gg,null,"required")),h=p?r.createElement(Bg,{className:l?"deprecated":"",kind:u,title:a},r.createElement(Lp,null),r.createElement("button",{onClick:this.toggle,onKeyPress:this.handleKeyPress,"aria-label":`expand ${a}`},!e&&s.map(e=>e+".​"),r.createElement("span",{className:"property-name"},a),r.createElement($p,{direction:d?"down":"right"})),f):r.createElement(Ip,{className:l?"deprecated":void 0,kind:u,title:a},r.createElement(Lp,null),!e&&s.map(e=>e+".​"),r.createElement("span",{className:"property-name"},a),f);return r.createElement(r.Fragment,null,r.createElement("tr",{className:i?"last "+t:t},h,r.createElement(Rp,null,r.createElement(ky,((e,t)=>{for(var r in t||(t={}))Oy.call(t,r)&&Py(e,r,t[r]);if(Ey)for(var r of Ey(t))_y.call(t,r)&&Py(e,r,t[r]);return e})({},this.props)))),d&&p&&r.createElement("tr",{key:n.name+"inner"},r.createElement(Np,{colSpan:2},r.createElement(Dp,null,r.createElement(cb,{schema:n.schema,fieldParentsName:[...s||[],n.name],skipReadOnly:this.props.skipReadOnly,skipWriteOnly:this.props.skipWriteOnly,showTitle:this.props.showTitle,level:this.props.level})))))}};$y.contextType=Os,$y=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],$y);Object.defineProperty,Object.getOwnPropertyDescriptor;let Ay=class extends r.Component{constructor(){super(...arguments),this.changeActiveChild=e=>{void 0!==e.idx&&this.props.parent.activateOneOf(e.idx)}}sortOptions(e,t){if(0===t.length)return;const r={};t.forEach((e,t)=>{r[e]=t}),e.sort((e,t)=>r[e.value]>r[t.value]?1:-1)}render(){const{parent:e,enumValues:t}=this.props;if(void 0===e.oneOf)return null;const n=e.oneOf.map((e,t)=>({value:e.title,idx:t})),i=n[e.activeOneOf].value;return this.sortOptions(n,t),r.createElement(mf,{value:i,options:n,onChange:this.changeActiveChild,ariaLabel:"Example"})}};Ay=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Ay);const Cy=Fg(({schema:{fields:e=[],title:t},showTitle:n,discriminator:i,skipReadOnly:o,skipWriteOnly:s,level:a,fieldParentsName:l})=>{const{expandSingleSchemaField:c,showObjectSchemaExamples:u,schemasExpansionLevel:p}=r.useContext(Os),d=r.useMemo(()=>o||s?e.filter(e=>!(o&&e.schema.readOnly||s&&e.schema.writeOnly)):e,[o,s,e]),f=c&&1===d.length||p>=a;return r.createElement(Mp,null,n&&r.createElement(jp,null,t),r.createElement("tbody",null,ti(d,(e,t)=>r.createElement($y,{key:e.name,isLast:t,field:e,expandByDefault:f,fieldParentsName:Number(a)>1?l:[],renderDiscriminatorSwitch:(null==i?void 0:i.fieldName)===e.name?()=>r.createElement(Ay,{parent:i.parentSchema,enumValues:e.schema.enum}):void 0,className:e.expanded?"expanded":void 0,showExamples:u,skipReadOnly:o,skipWriteOnly:s,showTitle:n,level:a}))))});var jy=Object.defineProperty,Ty=Object.defineProperties,Ny=Object.getOwnPropertyDescriptors,Iy=Object.getOwnPropertySymbols,Ry=Object.prototype.hasOwnProperty,Ly=Object.prototype.propertyIsEnumerable,Dy=(e,t,r)=>t in e?jy(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,My=(e,t)=>{for(var r in t||(t={}))Ry.call(t,r)&&Dy(e,r,t[r]);if(Iy)for(var r of Iy(t))Ly.call(t,r)&&Dy(e,r,t[r]);return e},zy=(e,t)=>Ty(e,Ny(t));const Fy=gs.div` + padding-left: ${({theme:e})=>2*e.spacing.unit}px; +`;class By extends r.PureComponent{render(){const e=this.props.schema,t=e.items,n=this.props.fieldParentsName,i=void 0===e.minItems&&void 0===e.maxItems?"":`(${ua(e)})`,o=n?[...n.slice(0,-1),n[n.length-1]+"[]"]:n;return e.fields?r.createElement(Cy,zy(My({},this.props),{level:this.props.level,fieldParentsName:o})):!e.displayType||t||i.length?r.createElement("div",null,r.createElement(Up,null," Array ",i),r.createElement(Fy,null,r.createElement(cb,zy(My({},this.props),{schema:t,fieldParentsName:o}))),r.createElement(qp,null)):r.createElement("div",null,r.createElement(Vg,null,e.displayType))}}var Uy=Object.defineProperty,qy=Object.defineProperties,Vy=Object.getOwnPropertyDescriptor,Wy=Object.getOwnPropertyDescriptors,Hy=Object.getOwnPropertySymbols,Gy=Object.prototype.hasOwnProperty,Yy=Object.prototype.propertyIsEnumerable,Ky=(e,t,r)=>t in e?Uy(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Qy=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Vy(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Uy(t,r,o),o};let Xy=class extends r.Component{constructor(){super(...arguments),this.activateOneOf=()=>{this.props.schema.activateOneOf(this.props.idx)}}render(){const{idx:e,schema:t,subSchema:n}=this.props;return r.createElement(Bp,{$deprecated:n.deprecated,$active:e===t.activeOneOf,onClick:this.activateOneOf},n.title||n.typePrefix+n.displayType)}};Xy=Qy([Fg],Xy);let Jy=class extends r.Component{render(){const{schema:{oneOf:e},schema:t}=this.props;if(void 0===e)return null;const n=e[t.activeOneOf];return r.createElement("div",null,r.createElement(Fp,null," ",t.oneOfType," "),r.createElement(zp,null,e.map((e,n)=>r.createElement(Xy,{key:e.pointer,schema:t,subSchema:e,idx:n}))),r.createElement("div",null,e[t.activeOneOf].deprecated&&r.createElement(Ap,{type:"warning"},"Deprecated")),r.createElement(uy,{constraints:n.constraints}),r.createElement(cb,((e,t)=>qy(e,Wy(t)))(((e,t)=>{for(var r in t||(t={}))Gy.call(t,r)&&Ky(e,r,t[r]);if(Hy)for(var r of Hy(t))Yy.call(t,r)&&Ky(e,r,t[r]);return e})({},this.props),{schema:n})))}};Jy=Qy([Fg],Jy);const Zy=Fg(({schema:e})=>r.createElement("div",null,r.createElement(Vg,null,e.displayType),e.title&&r.createElement(Wg,null," ",e.title," "),r.createElement(Kg,null," ",hi("recursive")," ")));var eb=Object.defineProperty,tb=Object.defineProperties,rb=(Object.getOwnPropertyDescriptor,Object.getOwnPropertyDescriptors),nb=Object.getOwnPropertySymbols,ib=Object.prototype.hasOwnProperty,ob=Object.prototype.propertyIsEnumerable,sb=(e,t,r)=>t in e?eb(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,ab=(e,t)=>{for(var r in t||(t={}))ib.call(t,r)&&sb(e,r,t[r]);if(nb)for(var r of nb(t))ob.call(t,r)&&sb(e,r,t[r]);return e},lb=(e,t)=>tb(e,rb(t));let cb=class extends r.Component{render(){var e;const t=this.props,{schema:n}=t,i=((e,t)=>{var r={};for(var n in e)ib.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&nb)for(var n of nb(e))t.indexOf(n)<0&&ob.call(e,n)&&(r[n]=e[n]);return r})(t,["schema"]),o=(i.level||0)+1;if(!n)return r.createElement("em",null," Schema not provided ");const{type:s,oneOf:a,discriminatorProp:l,isCircular:c}=n;if(c)return r.createElement(Zy,{schema:n});if(void 0!==l){if(!a||!a.length)return console.warn(`Looks like you are using discriminator wrong: you don't have any definition inherited from the ${n.title}`),null;const e=a[n.activeOneOf];return e.isCircular?r.createElement(Zy,{schema:e}):r.createElement(Cy,lb(ab({},i),{level:o,schema:e,discriminator:{fieldName:l,parentSchema:n}}))}if(void 0!==a)return r.createElement(Jy,ab({schema:n},i));const u=pi(s)?s:[s];if(u.includes("object")){if(null==(e=n.fields)?void 0:e.length)return r.createElement(Cy,lb(ab({},this.props),{level:o}))}else if(u.includes("array"))return r.createElement(By,lb(ab({},this.props),{level:o}));const p={schema:n,name:"",required:!1,description:n.description,externalDocs:n.externalDocs,deprecated:!1,toggle:()=>null,expanded:!1};return r.createElement("div",null,r.createElement(ky,{field:p}))}};cb=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],cb);var ub=Object.defineProperty,pb=Object.defineProperties,db=Object.getOwnPropertyDescriptors,fb=Object.getOwnPropertySymbols,hb=Object.prototype.hasOwnProperty,mb=Object.prototype.propertyIsEnumerable,gb=(e,t,r)=>t in e?ub(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;class yb extends r.PureComponent{constructor(){super(...arguments),this.renderDropdown=e=>{return r.createElement(dh,(t=((e,t)=>{for(var r in t||(t={}))hb.call(t,r)&&gb(e,r,t[r]);if(fb)for(var r of fb(t))mb.call(t,r)&&gb(e,r,t[r]);return e})({Label:yf,Dropdown:lg},e),pb(t,db({variant:"dark"}))));var t}}static getMediaType(e,t){if(!e)return{};const r={schema:{$ref:e}};return t&&(r.examples={example:{$ref:t}}),r}get mediaModel(){const{parser:e,schemaRef:t,exampleRef:r,options:n}=this.props;return this._mediaModel||(this._mediaModel=new Fu(e,"json",!1,yb.getMediaType(t,r),n)),this._mediaModel}render(){const{showReadOnly:e=!0,showWriteOnly:t=!1,showExample:n=!0}=this.props;return r.createElement(cp,null,r.createElement(dp,null,r.createElement(lp,null,r.createElement(cb,{skipWriteOnly:!t,skipReadOnly:!e,schema:this.mediaModel.schema})),n&&r.createElement(pp,null,r.createElement(bb,null,r.createElement(ug,{renderDropdown:this.renderDropdown,mediaType:this.mediaModel})))))}}const bb=gs.div` + background: ${({theme:e})=>e.codeBlock.backgroundColor}; + & > div, + & > pre { + padding: ${e=>4*e.theme.spacing.unit}px; + margin: 0; + } + + & > div > pre { + padding: 0; + } +`,vb=(cs.div` + background-color: #e4e7eb; +`,cs.ul` + display: inline; + list-style: none; + padding: 0; + + li { + display: inherit; + + &:after { + content: ','; + } + &:last-child:after { + content: none; + } + } +`,cs.code` + font-size: ${e=>e.theme.typography.code.fontSize}; + font-family: ${e=>e.theme.typography.code.fontFamily}; + margin: 0 3px; + padding: 0.2em; + display: inline-block; + line-height: 1; + + &:after { + content: ','; + font-weight: normal; + } + + &:last-child:after { + content: none; + } +`),xb=cs.span` + &:after { + content: ' and '; + font-weight: normal; + } + + &:last-child:after { + content: none; + } + + ${wm}; +`,wb=cs.span` + ${e=>!e.$expanded&&"white-space: nowrap;"} + &:after { + content: ' or '; + ${e=>e.$expanded&&"content: ' or \\a';"} + white-space: pre; + } + + &:last-child:after, + &:only-child:after { + content: none; + } + + ${wm}; +`,kb=cs.div` + flex: 1 1 auto; + cursor: pointer; +`,Sb=cs.div` + width: ${e=>e.theme.schema.defaultDetailsWidth}; + text-overflow: ellipsis; + border-radius: 4px; + overflow: hidden; + ${e=>e.$expanded&&`background: ${e.theme.colors.gray[100]};\n padding: 8px 9.6px;\n margin: 20px 0;\n width: 100%;\n `}; + ${ms.lessThan("small")` + margin-top: 10px; + `} +`,Eb=cs(vp)` + display: inline-block; + margin: 0; +`,Ob=cs.div` + width: 100%; + display: flex; + margin: 1em 0; + flex-direction: ${e=>e.$expanded?"column":"row"}; + ${ms.lessThan("small")` + flex-direction: column; + `} +`,_b=cs.div` + margin: 0.5em 0; +`,Pb=cs.div` + border-bottom: 1px solid ${({theme:e})=>e.colors.border.dark}; + margin-bottom: 1.5em; + padding-bottom: 0.7em; + + h5 { + line-height: 1em; + margin: 0 0 0.6em; + font-size: ${({theme:e})=>e.typography.fontSize}; + } + + .redoc-markdown p:first-child { + display: inline; + } +`;function $b({children:e,height:t}){const n=r.createRef(),[i,o]=r.useState(!1),[s,a]=r.useState(!1);return r.useEffect(()=>{n.current&&n.current.clientHeight+20{o(!i)}},i?"See less":"See more")))}const Ab=cs.div` + overflow-y: hidden; +`,Cb=cs.div` + text-align: center; + line-height: 1.5em; + ${({$dimmed:e})=>e&&"background-image: linear-gradient(to bottom, transparent,rgb(255 255 255));\n position: relative;\n top: -0.5em;\n padding-top: 0.5em;\n background-position-y: -1em;\n "} +`,jb=cs.a` + cursor: pointer; +`,Tb=r.memo(function(e){const{type:t,flow:n,RequiredScopes:i}=e,o=Object.keys((null==n?void 0:n.scopes)||{});return r.createElement(r.Fragment,null,r.createElement(_b,null,r.createElement("b",null,"Flow type: "),r.createElement("code",null,t," ")),("implicit"===t||"authorizationCode"===t)&&r.createElement(_b,null,r.createElement("strong",null," Authorization URL: "),r.createElement("code",null,r.createElement("a",{target:"_blank",rel:"noopener noreferrer",href:n.authorizationUrl},n.authorizationUrl))),("password"===t||"clientCredentials"===t||"authorizationCode"===t)&&r.createElement(_b,null,r.createElement("b",null," Token URL: "),r.createElement("code",null,n.tokenUrl)),n.refreshUrl&&r.createElement(_b,null,r.createElement("strong",null," Refresh URL: "),r.createElement("code",null,n.refreshUrl)),!!o.length&&r.createElement(r.Fragment,null,i||null,r.createElement(_b,null,r.createElement("b",null," Scopes: ")),r.createElement($b,{height:"4em"},r.createElement("ul",null,o.map(e=>r.createElement("li",{key:e},r.createElement("code",null,e)," -"," ",r.createElement(Im,{className:"redoc-markdown",inline:!0,source:n.scopes[e]||""})))))))});function Nb(e){const{RequiredScopes:t,scheme:n}=e;return r.createElement(km,null,n.apiKey?r.createElement(r.Fragment,null,r.createElement(_b,null,r.createElement("b",null,(i=n.apiKey.in||"").charAt(0).toUpperCase()+i.slice(1)," parameter name: "),r.createElement("code",null,n.apiKey.name)),t):n.http?r.createElement(r.Fragment,null,r.createElement(_b,null,r.createElement("b",null,"HTTP Authorization Scheme: "),r.createElement("code",null,n.http.scheme)),r.createElement(_b,null,"bearer"===n.http.scheme&&n.http.bearerFormat&&r.createElement(r.Fragment,null,r.createElement("b",null,"Bearer format: "),r.createElement("code",null,n.http.bearerFormat))),t):n.openId?r.createElement(r.Fragment,null,r.createElement(_b,null,r.createElement("b",null,"Connect URL: "),r.createElement("code",null,r.createElement("a",{target:"_blank",rel:"noopener noreferrer",href:n.openId.connectUrl},n.openId.connectUrl))),t):n.flows?Object.keys(n.flows).map(e=>r.createElement(Tb,{key:e,type:e,RequiredScopes:t,flow:n.flows[e]})):null);var i}const Ib={oauth2:"OAuth2",apiKey:"API Key",http:"HTTP",openIdConnect:"OpenID Connect"};class Rb extends r.PureComponent{render(){return this.props.securitySchemes.schemes.map(e=>r.createElement(cp,{id:e.sectionId,key:e.id},r.createElement(dp,null,r.createElement(lp,null,r.createElement(gp,null,r.createElement(_p,{to:e.sectionId}),e.displayName),r.createElement(Im,{source:e.description||""}),r.createElement(Pb,null,r.createElement(_b,null,r.createElement("b",null,"Security Scheme Type: "),r.createElement("span",null,Ib[e.type]||e.type)),r.createElement(Nb,{scheme:e}))))))}}class Lb{constructor(e,t,r={},n=!0){var i,o,s,a;this.marker=new Ba,this.disposer=null,this.rawOptions=r,this.options=new _i(r,Db),this.scroll=new oh(this.options),th.updateOnHistory(za.currentId,this.scroll),this.spec=new Lf(e,t,this.options),this.menu=new th(this.spec,this.scroll,za),this.options.disableSearch||(this.search=new sh,n&&this.search.indexItems(this.menu.items),this.disposer=(i=this.menu,o="activeItemIdx",x(s=e=>{this.updateMarkOnMenu(e.newValue)})?function(e,t,r,n){return Kr(e,t).observe_(r,n)}(i,o,s,a):function(e,t,r){return Kr(e).observe_(t,r)}(i,o,s)))}static fromJS(e){const t=new Lb(e.spec.data,e.spec.url,e.options,!1);return t.menu.activeItemIdx=e.menu.activeItemIdx||0,t.menu.activate(t.menu.flatItems[t.menu.activeItemIdx]),t.options.disableSearch||t.search.load(e.searchIndex),t}onDidMount(){this.menu.updateOnHistory(),this.updateMarkOnMenu(this.menu.activeItemIdx)}dispose(){this.scroll.dispose(),this.menu.dispose(),this.search&&this.search.dispose(),null!=this.disposer&&this.disposer()}toJS(){return e=this,t=null,r=function*(){return{menu:{activeItemIdx:this.menu.activeItemIdx},spec:{url:this.spec.parser.specUrl,data:this.spec.parser.spec},searchIndex:this.search?yield this.search.toJS():void 0,options:this.rawOptions}},new Promise((n,i)=>{var o=e=>{try{a(r.next(e))}catch(e){i(e)}},s=e=>{try{a(r.throw(e))}catch(e){i(e)}},a=e=>e.done?n(e.value):Promise.resolve(e.value).then(o,s);a((r=r.apply(e,t)).next())});var e,t,r}updateMarkOnMenu(e){const t=Math.max(0,e),r=Math.min(this.menu.flatItems.length,t+5),n=[];for(let e=t;e({securitySchemes:e.spec.securitySchemes})},[ma]:{component:Rb,propsSelector:e=>({securitySchemes:e.spec.securitySchemes})},[ga]:{component:yb,propsSelector:e=>({parser:e.spec.parser,options:e.options})}}},Mb=gs(mp)` + margin-top: 0; + margin-bottom: 0.5em; + + ${ys("ApiHeader")}; +`,zb=gs.a` + border: 1px solid ${e=>e.theme.colors.primary.main}; + color: ${e=>e.theme.colors.primary.main}; + font-weight: normal; + margin-left: 0.5em; + padding: 4px 8px 4px; + display: inline-block; + text-decoration: none; + cursor: pointer; + + ${ys("DownloadButton")}; +`,Fb=gs.span` + &::before { + content: '|'; + display: inline-block; + opacity: 0.5; + width: ${15}px; + text-align: center; + } + + &:last-child::after { + display: none; + } +`,Bb=gs.div` + overflow: hidden; +`,Ub=gs.div` + display: flex; + flex-wrap: wrap; + // hide separator on new lines: idea from https://stackoverflow.com/a/31732902/1749888 + margin-left: -${15}px; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let qb=class extends r.Component{render(){const{store:e}=this.props,{info:t,externalDocs:n}=e.spec,i=e.options.hideDownloadButtons,o=t.downloadUrls,s=t.downloadFileName,a=t.license&&r.createElement(Fb,null,"License:"," ",t.license.identifier?t.license.identifier:r.createElement("a",{href:t.license.url},t.license.name))||null,l=t.contact&&t.contact.url&&r.createElement(Fb,null,"URL: ",r.createElement("a",{href:t.contact.url},t.contact.url))||null,c=t.contact&&t.contact.email&&r.createElement(Fb,null,t.contact.name||"E-mail",":"," ",r.createElement("a",{href:"mailto:"+t.contact.email},t.contact.email))||null,u=t.termsOfService&&r.createElement(Fb,null,r.createElement("a",{href:t.termsOfService},"Terms of Service"))||null,p=t.version&&r.createElement("span",null,"(",t.version,")")||null;return r.createElement(cp,null,r.createElement(dp,null,r.createElement(lp,{className:"api-info"},r.createElement(Mb,null,t.title," ",p),!i&&r.createElement("p",null,hi("downloadSpecification"),":",null==o?void 0:o.map(({title:e,url:t})=>r.createElement(zb,{download:s||!0,target:"_blank",href:t,rel:"noreferrer",key:t},e))),r.createElement(km,null,(t.license||t.contact||t.termsOfService)&&r.createElement(Bb,null,r.createElement(Ub,null,c," ",l," ",a," ",u))||null),r.createElement(Im,{source:e.spec.info.summary,"data-role":"redoc-summary"}),r.createElement(Im,{source:e.spec.info.description,"data-role":"redoc-description"}),n&&r.createElement(ry,{externalDocs:n}))))}};qb=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],qb);const Vb=gs.img` + max-height: ${e=>e.theme.logo.maxHeight}; + max-width: ${e=>e.theme.logo.maxWidth}; + padding: ${e=>e.theme.logo.gutter}; + width: 100%; + display: block; +`,Wb=gs.div` + text-align: center; +`,Hb=gs.a` + display: inline-block; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let Gb=class extends r.Component{render(){const{info:e}=this.props,t=e["x-logo"];if(!t||!t.url)return null;const n=t.href||e.contact&&e.contact.url,i=t.altText?t.altText:"logo",o=r.createElement(Vb,{src:t.url,alt:i});return r.createElement(Wb,{style:{backgroundColor:t.backgroundColor}},n?(s=n,e=>r.createElement(Hb,{href:s},e))(o):o);var s}};Gb=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Gb);var Yb=Object.defineProperty,Kb=Object.getOwnPropertySymbols,Qb=Object.prototype.hasOwnProperty,Xb=Object.prototype.propertyIsEnumerable,Jb=(e,t,r)=>t in e?Yb(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Zb=(e,t)=>{for(var r in t||(t={}))Qb.call(t,r)&&Jb(e,r,t[r]);if(Kb)for(var r of Kb(t))Xb.call(t,r)&&Jb(e,r,t[r]);return e};class ev extends r.Component{render(){return r.createElement(Ps,null,e=>r.createElement(kp,null,t=>this.renderWithOptionsAndStore(e,t)))}renderWithOptionsAndStore(e,t){const{source:n,htmlWrap:i=e=>e}=this.props;if(!t)throw new Error("When using components in markdown, store prop must be provided");const o=new Ll(e,this.props.parentId).renderMdWithComponents(n);return o.length?o.map((e,n)=>{if("string"==typeof e)return r.cloneElement(i(r.createElement(Nm,{html:e,inline:!1,compact:!1})),{key:n});const o=e.component;return r.createElement(o,Zb({key:n},Zb(Zb({},e.props),e.propsSelector(t))))}):null}}var tv=n(2485);const rv=gs.span.attrs(e=>({className:`operation-type ${e.type}`}))` + width: 9ex; + display: inline-block; + height: ${e=>e.theme.typography.code.fontSize}; + line-height: ${e=>e.theme.typography.code.fontSize}; + background-color: ${e=>e.color||"#333"}; + border-radius: 3px; + background-repeat: no-repeat; + background-position: 6px 4px; + font-size: 7px; + font-family: Verdana, sans-serif; // web-safe + color: white; + text-transform: uppercase; + text-align: center; + font-weight: bold; + vertical-align: middle; + margin-right: 6px; + margin-top: 2px; + + &.get { + background-color: ${({theme:e})=>e.colors.http.get}; + } + + &.post { + background-color: ${({theme:e})=>e.colors.http.post}; + } + + &.put { + background-color: ${({theme:e})=>e.colors.http.put}; + } + + &.options { + background-color: ${({theme:e})=>e.colors.http.options}; + } + + &.patch { + background-color: ${({theme:e})=>e.colors.http.patch}; + } + + &.delete { + background-color: ${({theme:e})=>e.colors.http.delete}; + } + + &.basic { + background-color: ${({theme:e})=>e.colors.http.basic}; + } + + &.link { + background-color: ${({theme:e})=>e.colors.http.link}; + } + + &.head { + background-color: ${({theme:e})=>e.colors.http.head}; + } + + &.hook { + background-color: ${({theme:e})=>e.colors.primary.main}; + } + + &.schema { + background-color: ${({theme:e})=>e.colors.http.basic}; + } +`;function nv(e,{theme:t},r){return e>1?t.sidebar.level1Items[r]:1===e?t.sidebar.groupItems[r]:""}const iv=gs.ul` + margin: 0; + padding: 0; + + &:first-child { + padding-bottom: 32px; + } + + & & { + font-size: 0.929em; + } + + ${e=>e.$expanded?"":"display: none;"}; +`,ov=gs.li` + list-style: none inside none; + overflow: hidden; + text-overflow: ellipsis; + padding: 0; + ${e=>0===e.depth?"margin-top: 15px":""}; +`,sv={0:ps` + opacity: 0.7; + text-transform: ${({theme:e})=>e.sidebar.groupItems.textTransform}; + font-size: 0.8em; + padding-bottom: 0; + cursor: default; + `,1:ps` + font-size: 0.929em; + text-transform: ${({theme:e})=>e.sidebar.level1Items.textTransform}; + `},av=gs.label.attrs(e=>({className:tv("-depth"+e.$depth,{active:e.$active})}))` + cursor: pointer; + color: ${e=>e.$active?nv(e.$depth,e,"activeTextColor"):e.theme.sidebar.textColor}; + margin: 0; + padding: 12.5px ${e=>4*e.theme.spacing.unit}px; + ${({$depth:e,$type:t,theme:r})=>"section"===t&&e>1&&"padding-left: "+8*r.spacing.unit+"px;"||""} + display: flex; + justify-content: space-between; + font-family: ${e=>e.theme.typography.headings.fontFamily}; + ${e=>sv[e.$depth]}; + background-color: ${e=>e.$active?nv(e.$depth,e,"activeBackgroundColor"):e.theme.sidebar.backgroundColor}; + + ${e=>e.$deprecated&&Cp||""}; + + &:hover { + color: ${e=>nv(e.$depth,e,"activeTextColor")}; + background-color: ${e=>nv(e.$depth,e,"activeBackgroundColor")}; + } + + ${$p} { + height: ${({theme:e})=>e.sidebar.arrow.size}; + width: ${({theme:e})=>e.sidebar.arrow.size}; + polygon { + fill: ${({theme:e})=>e.sidebar.arrow.color}; + } + } +`,lv=gs.span` + display: inline-block; + vertical-align: middle; + width: ${e=>e.width?e.width:"auto"}; + overflow: hidden; + text-overflow: ellipsis; +`,cv=gs.div` + ${({theme:e})=>ps` + font-size: 0.8em; + margin-top: ${2*e.spacing.unit}px; + text-align: center; + position: fixed; + width: ${e.sidebar.width}; + bottom: 0; + background: ${e.sidebar.backgroundColor}; + + a, + a:visited, + a:hover { + color: ${e.sidebar.textColor} !important; + padding: ${e.spacing.unit}px 0; + border-top: 1px solid ${Dn(.1,e.sidebar.backgroundColor)}; + text-decoration: none; + display: flex; + align-items: center; + justify-content: center; + } + `}; + img { + width: 15px; + margin-right: 5px; + } + + ${ms.lessThan("small")` + width: 100%; + `}; +`,uv=gs.button` + border: 0; + width: 100%; + text-align: left; + & > * { + vertical-align: middle; + } + + ${$p} { + polygon { + fill: ${({theme:e})=>Dn(e.colors.tonalOffset,e.colors.gray[100])}; + } + } +`,pv=gs.span` + text-decoration: ${e=>e.$deprecated?"line-through":"none"}; + margin-right: 8px; +`,dv=gs(rv)` + margin: 0 5px 0 0; +`,fv=gs(e=>{const{name:t,opened:n,className:i,onClick:o,httpVerb:s,deprecated:a}=e;return r.createElement(uv,{className:i,onClick:o||void 0},r.createElement(dv,{type:s},ba(s)),r.createElement($p,{size:"1.5em",direction:n?"down":"right",float:"left"}),r.createElement(pv,{$deprecated:a},t),a?r.createElement(Ap,{type:"warning"}," ",hi("deprecated")," "):null)})` + padding: 10px; + border-radius: 2px; + margin-bottom: 4px; + line-height: 1.5em; + background-color: ${({theme:e})=>e.colors.gray[100]}; + cursor: pointer; + outline-color: ${({theme:e})=>Dn(e.colors.tonalOffset,e.colors.gray[100])}; +`,hv=gs.div` + padding: 10px 25px; + background-color: ${({theme:e})=>e.colors.gray[50]}; + margin-bottom: 5px; + margin-top: 5px; +`;class mv extends r.PureComponent{constructor(){super(...arguments),this.selectElement=()=>{Um.selectElement(this.child)}}render(){const{children:e}=this.props;return r.createElement("div",{ref:e=>this.child=e,onClick:this.selectElement,onFocus:this.selectElement,tabIndex:0,role:"button"},e)}}const gv=gs.div` + cursor: pointer; + position: relative; + margin-bottom: 5px; +`,yv=gs.span` + font-family: ${e=>e.theme.typography.code.fontFamily}; + margin-left: 10px; + flex: 1; + overflow-x: hidden; + text-overflow: ellipsis; +`,bv=gs.button` + outline: 0; + color: inherit; + width: 100%; + text-align: left; + cursor: pointer; + padding: 10px 30px 10px ${e=>e.$inverted?"10px":"20px"}; + border-radius: ${e=>e.$inverted?"0":"4px 4px 0 0"}; + background-color: ${e=>e.$inverted?"transparent":e.theme.codeBlock.backgroundColor}; + display: flex; + white-space: nowrap; + align-items: center; + border: ${e=>e.$inverted?"0":"1px solid transparent"}; + border-bottom: ${e=>e.$inverted?"1px solid #ccc":"0"}; + transition: border-color 0.25s ease; + + ${e=>e.$expanded&&!e.$inverted&&`border-color: ${e.theme.colors.border.dark};`||""} + + .${yv} { + color: ${e=>e.$inverted?e.theme.colors.text.primary:"#ffffff"}; + } + &:focus { + box-shadow: inset 0 2px 2px rgba(0, 0, 0, 0.45), 0 2px 0 rgba(128, 128, 128, 0.25); + } +`,vv=gs.span.attrs(e=>({className:`http-verb ${e.type}`}))` + font-size: ${e=>e.$compact?"0.8em":"0.929em"}; + line-height: ${e=>e.$compact?"18px":"20px"}; + background-color: ${e=>e.theme.colors.http[e.type]||"#999999"}; + color: #ffffff; + padding: ${e=>e.$compact?"2px 8px":"3px 10px"}; + text-transform: uppercase; + font-family: ${e=>e.theme.typography.headings.fontFamily}; + margin: 0; +`,xv=gs.div` + position: absolute; + width: 100%; + z-index: 100; + background: ${e=>e.theme.rightPanel.servers.overlay.backgroundColor}; + color: ${e=>e.theme.rightPanel.servers.overlay.textColor}; + box-sizing: border-box; + box-shadow: 0 0 6px rgba(0, 0, 0, 0.33); + overflow: hidden; + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + transition: all 0.25s ease; + visibility: hidden; + ${e=>e.$expanded?"visibility: visible;":"transform: translateY(-50%) scaleY(0);"} +`,wv=gs.div` + padding: 10px; +`,kv=gs.div` + padding: 5px; + border: 1px solid #ccc; + background: ${e=>e.theme.rightPanel.servers.url.backgroundColor}; + word-break: break-all; + color: ${e=>e.theme.colors.primary.main}; + > span { + color: ${e=>e.theme.colors.text.primary}; + } +`;class Sv extends r.Component{constructor(e){super(e),this.toggle=()=>{this.setState({expanded:!this.state.expanded})},this.state={expanded:!1}}render(){const{operation:e,inverted:t,hideHostname:n}=this.props,{expanded:i}=this.state;return r.createElement(Os.Consumer,null,o=>r.createElement(gv,null,r.createElement(bv,{onClick:this.toggle,$expanded:i,$inverted:t},r.createElement(vv,{type:e.httpVerb,$compact:this.props.compact},e.httpVerb),r.createElement(yv,null,e.path),r.createElement($p,{float:"right",color:t?"black":"white",size:"20px",direction:i?"up":"down",style:{marginRight:"-25px"}})),r.createElement(xv,{$expanded:i,"aria-hidden":!i},e.servers.map(t=>{const i=o.expandDefaultServerVariables?function(e,t={}){return e.replace(/(?:{)([\w-.]+)(?:})/g,(e,r)=>t[r]&&t[r].default||e)}(t.url,t.variables):t.url,s=function(e){try{return ci(e).pathname}catch(t){return e}}(i);return r.createElement(wv,{key:i},r.createElement(Im,{source:t.description||"",compact:!0}),r.createElement(mv,null,r.createElement(kv,null,r.createElement("span",null,n||o.hideHostname?"/"===s?"":s:i),e.path)))}))))}}class Ev extends r.PureComponent{render(){const{place:e,parameters:t}=this.props;return t&&t.length?r.createElement("div",{key:e},r.createElement(vp,null,e," Parameters"),r.createElement(Mp,null,r.createElement("tbody",null,ti(t,(e,t)=>r.createElement($y,{key:e.name,isLast:t,field:e,showExamples:!0}))))):null}}Object.defineProperty,Object.getOwnPropertyDescriptor;let Ov=class extends r.Component{constructor(){super(...arguments),this.switchMedia=({idx:e})=>{this.props.content&&void 0!==e&&this.props.content.activate(e)}}render(){const{content:e}=this.props;if(!e||!e.mediaTypes||!e.mediaTypes.length)return null;const t=e.activeMimeIdx,n=e.mediaTypes.map((e,t)=>({value:e.name,idx:t})),i=({children:e})=>this.props.withLabel?r.createElement(ag,null,r.createElement(sg,null,"Content type"),e):e;return r.createElement(r.Fragment,null,r.createElement(i,null,this.props.renderDropdown({value:n[t].value,options:n,onChange:this.switchMedia,ariaLabel:"Content type"})),this.props.children(e.active))}};Ov=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Ov);var _v=Object.defineProperty,Pv=Object.getOwnPropertySymbols,$v=Object.prototype.hasOwnProperty,Av=Object.prototype.propertyIsEnumerable,Cv=(e,t,r)=>t in e?_v(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,jv=(e,t)=>{for(var r in t||(t={}))$v.call(t,r)&&Cv(e,r,t[r]);if(Pv)for(var r of Pv(t))Av.call(t,r)&&Cv(e,r,t[r]);return e};const Tv=["path","query","cookie","header"];class Nv extends r.PureComponent{orderParams(e){const t={};return e.forEach(e=>{var r,n,i;i=e,(r=t)[n=e.in]||(r[n]=[]),r[n].push(i)}),t}render(){const{body:e,parameters:t=[]}=this.props;if(void 0===e&&void 0===t)return null;const n=this.orderParams(t),i=t.length>0?Tv:[],o=e&&e.content,s=e&&e.description,a=e&&e.required;return r.createElement(r.Fragment,null,i.map(e=>r.createElement(Ev,{key:e,place:e,parameters:n[e]})),o&&r.createElement(Rv,{content:o,description:s,bodyRequired:a}))}}function Iv(e){var t=e,{bodyRequired:n}=t,i=((e,t)=>{var r={};for(var n in e)$v.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(null!=e&&Pv)for(var n of Pv(e))t.indexOf(n)<0&&Av.call(e,n)&&(r[n]=e[n]);return r})(t,["bodyRequired"]);const o="boolean"==typeof n&&!!n,s="boolean"==typeof n&&!n;return r.createElement(vp,{key:"header"},"Request Body schema: ",r.createElement(dh,jv({},i)),o&&r.createElement(Dv,null,"required"),s&&r.createElement(Mv,null,"optional"))}function Rv(e){const{content:t,description:n,bodyRequired:i}=e,{isRequestType:o}=t;return r.createElement(Ov,{content:t,renderDropdown:e=>r.createElement(Iv,jv({bodyRequired:i},e))},({schema:e})=>r.createElement(r.Fragment,null,void 0!==n&&r.createElement(Im,{source:n}),"object"===(null==e?void 0:e.type)&&r.createElement(uy,{constraints:(null==e?void 0:e.constraints)||[]}),r.createElement(cb,{skipReadOnly:o,skipWriteOnly:!o,key:"schema",schema:e})))}const Lv="\n text-transform: lowercase;\n margin-left: 0;\n line-height: 1.5em;\n",Dv=gs(Gg)` + ${Lv} +`,Mv=gs("div")` + ${Lv} + color: ${({theme:e})=>e.colors.text.secondary}; + font-size: ${e=>e.theme.schema.labelsTextSize}; +`,zv=gs(r.memo(function({title:e,type:t,empty:n,code:i,opened:o,className:s,onClick:a}){return r.createElement("button",{className:s,onClick:!n&&a||void 0,"aria-expanded":o,disabled:n},!n&&r.createElement($p,{size:"1.5em",color:t,direction:o?"down":"right",float:"left"}),r.createElement(Uv,null,i," "),r.createElement(Im,{compact:!0,inline:!0,source:e}))}))` + display: block; + border: 0; + width: 100%; + text-align: left; + padding: 10px; + border-radius: 2px; + margin-bottom: 4px; + line-height: 1.5em; + cursor: pointer; + + color: ${e=>e.theme.colors.responses[e.type].color}; + background-color: ${e=>e.theme.colors.responses[e.type].backgroundColor}; + &:focus { + outline: auto ${e=>e.theme.colors.responses[e.type].color}; + } + ${e=>e.empty?'\ncursor: default;\n&::before {\n content: "—";\n font-weight: bold;\n width: 1.5em;\n text-align: center;\n display: inline-block;\n vertical-align: top;\n}\n&:focus {\n outline: 0;\n}\n':""}; +`,Fv=gs.div` + padding: 10px; +`,Bv=gs(vp).attrs({as:"caption"})` + text-align: left; + margin-top: 1em; + caption-side: top; +`,Uv=gs.strong` + vertical-align: top; +`;class qv extends r.PureComponent{render(){const{headers:e}=this.props;return void 0===e||0===e.length?null:r.createElement(Mp,null,r.createElement(Bv,null," Response Headers "),r.createElement("tbody",null,ti(e,(e,t)=>r.createElement($y,{isLast:t,key:e.name,field:e,showExamples:!0}))))}}var Vv=Object.defineProperty,Wv=Object.getOwnPropertySymbols,Hv=Object.prototype.hasOwnProperty,Gv=Object.prototype.propertyIsEnumerable,Yv=(e,t,r)=>t in e?Vv(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;class Kv extends r.PureComponent{constructor(){super(...arguments),this.renderDropdown=e=>r.createElement(vp,{key:"header"},"Response Schema: ",r.createElement(dh,((e,t)=>{for(var r in t||(t={}))Hv.call(t,r)&&Yv(e,r,t[r]);if(Wv)for(var r of Wv(t))Gv.call(t,r)&&Yv(e,r,t[r]);return e})({},e)))}render(){const{description:e,extensions:t,headers:n,content:i}=this.props.response;return r.createElement(r.Fragment,null,e&&r.createElement(Im,{source:e}),r.createElement(ay,{extensions:t}),r.createElement(qv,{headers:n}),r.createElement(Ov,{content:i,renderDropdown:this.renderDropdown},({schema:e})=>r.createElement(r.Fragment,null,"object"===(null==e?void 0:e.type)&&r.createElement(uy,{constraints:(null==e?void 0:e.constraints)||[]}),r.createElement(cb,{skipWriteOnly:!0,key:"schema",schema:e}))))}}const Qv=Fg(({response:e})=>{const{extensions:t,headers:n,type:i,summary:o,description:s,code:a,expanded:l,content:c}=e,u=r.useMemo(()=>void 0===c?[]:c.mediaTypes.filter(e=>void 0!==e.schema),[c]),p=r.useMemo(()=>!(t&&0!==Object.keys(t).length||0!==n.length||0!==u.length||s),[t,n,u,s]);return r.createElement("div",null,r.createElement(zv,{onClick:()=>e.toggle(),type:i,empty:p,title:o||"",code:a,opened:l}),l&&!p&&r.createElement(Fv,null,r.createElement(Kv,{response:e})))}),Xv=gs.h3` + font-size: 1.3em; + padding: 0.2em 0; + margin: 3em 0 1.1em; + color: ${({theme:e})=>e.colors.text.primary}; + font-weight: normal; +`;class Jv extends r.PureComponent{render(){const{responses:e,isCallback:t}=this.props;return e&&0!==e.length?r.createElement("div",null,r.createElement(Xv,null,hi(t?"callbackResponses":"responses")),e.map(e=>r.createElement(Qv,{key:e.code,response:e}))):null}}function Zv(e){const{security:t,showSecuritySchemeType:n,expanded:i}=e,o=t.schemes.length>1;return 0===t.schemes.length?r.createElement(wb,{$expanded:i},"None"):r.createElement(wb,{$expanded:i},o&&"(",t.schemes.map(e=>r.createElement(xb,{key:e.id},n&&`${Ib[e.type]||e.type}: `,r.createElement("i",null,e.displayName),i&&e.scopes.length?[" (",e.scopes.map(e=>r.createElement(vb,{key:e},e)),") "]:null)),o&&") ")}const ex=({scopes:e})=>e.length?r.createElement("div",null,r.createElement("b",null,"Required scopes: "),e.map((e,t)=>r.createElement(r.Fragment,{key:t},r.createElement("code",null,e)," "))):null;function tx(e){const t=(0,r.useContext)(xp),n=null==t?void 0:t.options.showSecuritySchemeType,[i,o]=(0,r.useState)(!1),{securities:s}=e;if(!(null==s?void 0:s.length)||(null==t?void 0:t.options.hideSecuritySection))return null;const a=null==t?void 0:t.spec.securitySchemes.schemes.filter(({id:e})=>s.find(t=>t.schemes.find(t=>t.id===e)));return r.createElement(r.Fragment,null,r.createElement(Ob,{$expanded:i},r.createElement(kb,{onClick:()=>o(!i)},r.createElement(Eb,null,"Authorizations:"),r.createElement($p,{size:"1.3em",direction:i?"down":"right"})),r.createElement(Sb,{$expanded:i},s.map((e,t)=>r.createElement(Zv,{key:t,expanded:i,showSecuritySchemeType:n,security:e})))),i&&!!(null==a?void 0:a.length)&&a.map((e,t)=>r.createElement(Pb,{key:t},r.createElement("h5",null,r.createElement(rx,null)," ",Ib[e.type]||e.type,": ",e.id),r.createElement(Im,{source:e.description||""}),r.createElement(Nb,{key:e.id,scheme:e,RequiredScopes:r.createElement(ex,{scopes:nx(e.id,s)})}))))}const rx=()=>r.createElement("svg",{xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",width:"11",height:"11"},r.createElement("path",{fill:"currentColor",d:"M18 10V6A6 6 0 0 0 6 6v4H3v14h18V10h-3zM8 6c0-2.206 1.794-4 4-4s4 1.794 4 4v4H8V6zm11 16H5V12h14v10z"}));function nx(e,t){const r=[];let n=t.length;for(;n--;){const i=t[n];let o=i.schemes.length;for(;o--;){const t=i.schemes[o];t.id===e&&Array.isArray(t.scopes)&&r.push(...t.scopes)}}return Array.from(new Set(r))}Object.defineProperty,Object.getOwnPropertyDescriptor;let ix=class extends r.Component{render(){const{operation:e}=this.props,{description:t,externalDocs:n}=e,i=!(!t&&!n);return r.createElement(hv,null,i&&r.createElement(ox,null,void 0!==t&&r.createElement(Im,{source:t}),n&&r.createElement(ry,{externalDocs:n})),r.createElement(Sv,{operation:this.props.operation,inverted:!0,compact:!0}),r.createElement(ay,{extensions:e.extensions}),r.createElement(tx,{securities:e.security}),r.createElement(Nv,{parameters:e.parameters,body:e.requestBody}),r.createElement(Jv,{responses:e.responses,isCallback:e.isCallback}))}};ix=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],ix);const ox=gs.div` + margin-bottom: ${({theme:e})=>3*e.spacing.unit}px; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let sx=class extends r.Component{constructor(){super(...arguments),this.toggle=()=>{this.props.callbackOperation.toggle()}}render(){const{name:e,expanded:t,httpVerb:n,deprecated:i}=this.props.callbackOperation;return r.createElement(r.Fragment,null,r.createElement(fv,{onClick:this.toggle,name:e,opened:t,httpVerb:n,deprecated:i}),t&&r.createElement(ix,{operation:this.props.callbackOperation}))}};sx=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],sx);class ax extends r.PureComponent{render(){const{callbacks:e}=this.props;return e&&0!==e.length?r.createElement("div",null,r.createElement(lx,null," Callbacks "),e.map(e=>e.operations.map((t,n)=>r.createElement(sx,{key:`${e.name}_${n}`,callbackOperation:t})))):null}}const lx=gs.h3` + font-size: 1.3em; + padding: 0.2em 0; + margin: 3em 0 1.1em; + color: ${({theme:e})=>e.colors.text.primary}; + font-weight: normal; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let cx=class extends r.Component{constructor(e){super(e),this.switchItem=({idx:e})=>{this.props.items&&void 0!==e&&this.setState({activeItemIdx:e})},this.state={activeItemIdx:0}}render(){const{items:e}=this.props;if(!e||!e.length)return null;const t=({children:e})=>this.props.label?r.createElement(ag,null,r.createElement(sg,null,this.props.label),e):e;return r.createElement(r.Fragment,null,r.createElement(t,null,this.props.renderDropdown({value:this.props.options[this.state.activeItemIdx].value,options:this.props.options,onChange:this.switchItem,ariaLabel:this.props.label||"Callback"})),this.props.children(e[this.state.activeItemIdx]))}};cx=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],cx);var ux=Object.defineProperty,px=Object.defineProperties,dx=(Object.getOwnPropertyDescriptor,Object.getOwnPropertyDescriptors),fx=Object.getOwnPropertySymbols,hx=Object.prototype.hasOwnProperty,mx=Object.prototype.propertyIsEnumerable,gx=(e,t,r)=>t in e?ux(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;let yx=class extends r.Component{constructor(){super(...arguments),this.renderDropdown=e=>{return r.createElement(dh,(t=((e,t)=>{for(var r in t||(t={}))hx.call(t,r)&&gx(e,r,t[r]);if(fx)for(var r of fx(t))mx.call(t,r)&&gx(e,r,t[r]);return e})({Label:og,Dropdown:lg},e),px(t,dx({variant:"dark"}))));var t}}render(){const e=this.props.content;return void 0===e?null:r.createElement(Ov,{content:e,renderDropdown:this.renderDropdown,withLabel:!0},e=>r.createElement(ug,{key:"samples",mediaType:e,renderDropdown:this.renderDropdown}))}};yx=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],yx);class bx extends r.Component{render(){const e=this.props.callback.codeSamples.find(e=>op(e));return e?r.createElement(vx,null,r.createElement(yx,{content:e.requestBodyContent})):null}}const vx=gs.div` + margin-top: 15px; +`;var xx=Object.defineProperty,wx=Object.defineProperties,kx=(Object.getOwnPropertyDescriptor,Object.getOwnPropertyDescriptors),Sx=Object.getOwnPropertySymbols,Ex=Object.prototype.hasOwnProperty,Ox=Object.prototype.propertyIsEnumerable,_x=(e,t,r)=>t in e?xx(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;let Px=class extends r.Component{constructor(){super(...arguments),this.renderDropdown=e=>{return r.createElement(dh,(t=((e,t)=>{for(var r in t||(t={}))Ex.call(t,r)&&_x(e,r,t[r]);if(Sx)for(var r of Sx(t))Ox.call(t,r)&&_x(e,r,t[r]);return e})({Label:og,Dropdown:lg},e),wx(t,kx({variant:"dark"}))));var t}}render(){const{callbacks:e}=this.props;if(!e||0===e.length)return null;const t=e.map(e=>e.operations.map(e=>e)).reduce((e,t)=>e.concat(t),[]);if(!t.some(e=>e.codeSamples.length>0))return null;const n=t.map((e,t)=>({value:`${e.httpVerb.toUpperCase()}: ${e.name}`,idx:t}));return r.createElement("div",null,r.createElement(bp,null," Callback payload samples "),r.createElement($x,null,r.createElement(cx,{items:t,renderDropdown:this.renderDropdown,label:"Callback",options:n},e=>r.createElement(bx,{key:"callbackPayloadSample",callback:e,renderDropdown:this.renderDropdown}))))}};Px.contextType=Os,Px=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Px);const $x=gs.div` + background: ${({theme:e})=>e.codeBlock.backgroundColor}; + padding: ${e=>4*e.theme.spacing.unit}px; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let Ax=class extends r.Component{render(){const{operation:e}=this.props,t=e.codeSamples,n=t.length>0,i=1===t.length&&this.context.hideSingleRequestSampleTab;return n&&r.createElement("div",null,r.createElement(bp,null," ",hi("requestSamples")," "),r.createElement(xd,{defaultIndex:0},r.createElement(pd,{hidden:i},t.map(e=>r.createElement(md,{key:e.lang+"_"+(e.label||"")},void 0!==e.label?e.label:e.lang))),t.map(e=>r.createElement(vd,{key:e.lang+"_"+(e.label||"")},op(e)?r.createElement("div",null,r.createElement(yx,{content:e.requestBodyContent})):r.createElement(tg,{lang:e.lang,source:e.source})))))||null}};Ax.contextType=Os,Ax=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Ax);Object.defineProperty,Object.getOwnPropertyDescriptor;let Cx=class extends r.Component{render(){const{operation:e}=this.props,t=e.responses.filter(e=>e.content&&e.content.hasSample);return t.length>0&&r.createElement("div",null,r.createElement(bp,null," ",hi("responseSamples")," "),r.createElement(xd,{defaultIndex:0},r.createElement(pd,null,t.map(e=>r.createElement(md,{className:"tab-"+e.type,key:e.code},e.code))),t.map(e=>r.createElement(vd,{key:e.code},r.createElement("div",null,r.createElement(yx,{content:e.content}))))))||null}};Cx=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],Cx);var jx=Object.defineProperty,Tx=Object.defineProperties,Nx=Object.getOwnPropertyDescriptors,Ix=Object.getOwnPropertySymbols,Rx=Object.prototype.hasOwnProperty,Lx=Object.prototype.propertyIsEnumerable,Dx=(e,t,r)=>t in e?jx(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;const Mx=gs.div` + margin-bottom: ${({theme:e})=>6*e.spacing.unit}px; +`,zx=Fg(({operation:e})=>{const{name:t,description:n,deprecated:i,externalDocs:o,isWebhook:s,httpVerb:a,badges:l}=e,c=!(!n&&!o),{showWebhookVerb:u}=r.useContext(Os),p=l.filter(({position:e})=>"before"===e),d=l.filter(({position:e})=>"after"===e);return r.createElement(Os.Consumer,null,l=>r.createElement(dp,((e,t)=>Tx(e,Nx(t)))(((e,t)=>{for(var r in t||(t={}))Rx.call(t,r)&&Dx(e,r,t[r]);if(Ix)for(var r of Ix(t))Lx.call(t,r)&&Dx(e,r,t[r]);return e})({},{[eh]:e.operationHash}),{id:e.operationHash}),r.createElement(lp,null,r.createElement(gp,null,r.createElement(_p,{to:e.id}),p.map(({name:e,color:t})=>r.createElement(Ap,{type:"primary",key:e,color:t},e)),t," ",i&&r.createElement(Ap,{type:"warning"}," Deprecated "),s&&r.createElement(Ap,{type:"primary"}," ","Webhook ",u&&a&&"| "+a.toUpperCase()),d.map(({name:e,color:t})=>r.createElement(Ap,{type:"primary",key:e,color:t},e))),l.pathInMiddlePanel&&!s&&r.createElement(Sv,{operation:e,inverted:!0}),c&&r.createElement(Mx,null,void 0!==n&&r.createElement(Im,{source:n}),o&&r.createElement(ry,{externalDocs:o})),r.createElement(ay,{extensions:e.extensions}),r.createElement(tx,{securities:e.security}),r.createElement(Nv,{parameters:e.parameters,body:e.requestBody}),r.createElement(Jv,{responses:e.responses}),r.createElement(ax,{callbacks:e.callbacks})),r.createElement(pp,null,!l.pathInMiddlePanel&&!s&&r.createElement(Sv,{operation:e}),r.createElement(Ax,{operation:e}),r.createElement(Cx,{operation:e}),r.createElement(Px,{callbacks:e.callbacks}))))});var Fx=Object.defineProperty,Bx=Object.getOwnPropertyDescriptor,Ux=Object.getOwnPropertySymbols,qx=Object.prototype.hasOwnProperty,Vx=Object.prototype.propertyIsEnumerable,Wx=(e,t,r)=>t in e?Fx(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Hx=(e,t,r,n)=>{for(var i,o=n>1?void 0:n?Bx(t,r):t,s=e.length-1;s>=0;s--)(i=e[s])&&(o=(n?i(t,r,o):i(o))||o);return n&&o&&Fx(t,r,o),o};let Gx=class extends r.Component{render(){const e=this.props.items;return 0===e.length?null:e.map(e=>r.createElement(Yx,{key:e.id,item:e}))}};Gx=Hx([Fg],Gx);let Yx=class extends r.Component{render(){const e=this.props.item;let t;const{type:n}=e;switch(n){case"group":t=null;break;case"tag":case"section":default:t=r.createElement(Qx,((e,t)=>{for(var r in t||(t={}))qx.call(t,r)&&Wx(e,r,t[r]);if(Ux)for(var r of Ux(t))Vx.call(t,r)&&Wx(e,r,t[r]);return e})({},this.props));break;case"operation":t=r.createElement(Xx,{item:e})}return r.createElement(r.Fragment,null,t&&r.createElement(cp,{id:e.id,$underlined:"operation"===e.type},t),e.items&&r.createElement(Gx,{items:e.items}))}};Yx=Hx([Fg],Yx);const Kx=e=>r.createElement(lp,{$compact:!0},e);let Qx=class extends r.Component{render(){const{name:e,description:t,externalDocs:n,level:i}=this.props.item,o=2===i?yp:gp;return r.createElement(r.Fragment,null,r.createElement(dp,null,r.createElement(lp,{$compact:!1},r.createElement(o,null,r.createElement(_p,{to:this.props.item.id}),e))),r.createElement(ev,{parentId:this.props.item.id,source:t||"",htmlWrap:Kx}),n&&r.createElement(dp,null,r.createElement(lp,null,r.createElement(ry,{externalDocs:n}))))}};Qx=Hx([Fg],Qx);let Xx=class extends r.Component{render(){return r.createElement(zx,{operation:this.props.item})}};Xx=Hx([Fg],Xx);var Jx=Object.defineProperty,Zx=Object.defineProperties,ew=(Object.getOwnPropertyDescriptor,Object.getOwnPropertyDescriptors),tw=Object.getOwnPropertySymbols,rw=Object.prototype.hasOwnProperty,nw=Object.prototype.propertyIsEnumerable,iw=(e,t,r)=>t in e?Jx(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;let ow=class extends r.Component{constructor(){super(...arguments),this.ref=r.createRef(),this.activate=e=>{this.props.onActivate(this.props.item),e.stopPropagation()}}componentDidMount(){this.scrollIntoViewIfActive()}componentDidUpdate(){this.scrollIntoViewIfActive()}scrollIntoViewIfActive(){this.props.item.active&&this.ref.current&&Jn(this.ref.current)}render(){const{item:e,withoutChildren:t}=this.props;return r.createElement(ov,{tabIndex:0,onClick:this.activate,onKeyDown:e=>{"Enter"!==e.key&&" "!==e.key||(this.props.onActivate(this.props.item),e.stopPropagation())},depth:e.depth,"data-item-id":e.id,role:"menuitem","aria-label":e.sidebarLabel,"aria-expanded":e.expanded},"operation"===e.type?r.createElement(sw,((e,t)=>Zx(e,ew(t)))(((e,t)=>{for(var r in t||(t={}))rw.call(t,r)&&iw(e,r,t[r]);if(tw)for(var r of tw(t))nw.call(t,r)&&iw(e,r,t[r]);return e})({},this.props),{item:e})):r.createElement(av,{$depth:e.depth,$active:e.active,$type:e.type,ref:this.ref},"schema"===e.type&&r.createElement(rv,{type:"schema"},"schema"),r.createElement(lv,{width:"calc(100% - 38px)",title:e.sidebarLabel},e.sidebarLabel,this.props.children),e.depth>0&&e.items.length>0&&r.createElement($p,{float:"right",direction:e.expanded?"down":"right"})||null),!t&&e.items&&e.items.length>0&&r.createElement(dw,{expanded:e.expanded,items:e.items,onActivate:this.props.onActivate}))}};ow=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],ow);const sw=Fg(e=>{var t;const{item:n}=e,i=r.createRef(),{showWebhookVerb:o}=r.useContext(Os);return r.useEffect(()=>{e.item.active&&i.current&&Jn(i.current)},[e.item.active,i]),r.createElement(av,{$depth:n.depth,$active:n.active,$deprecated:n.deprecated,ref:i},n.badges&&(null==(t=n.badges)?void 0:t.map(({name:e,color:t})=>r.createElement(rv,{type:"badge",color:t,key:e},e))),n.isWebhook?r.createElement(rv,{type:"hook"},o?n.httpVerb:hi("webhook")):r.createElement(rv,{type:n.httpVerb},ba(n.httpVerb)),r.createElement(lv,{tabIndex:0,width:"calc(100% - 38px)"},n.sidebarLabel,e.children))});var aw=Object.defineProperty,lw=(Object.getOwnPropertyDescriptor,Object.getOwnPropertySymbols),cw=Object.prototype.hasOwnProperty,uw=Object.prototype.propertyIsEnumerable,pw=(e,t,r)=>t in e?aw(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r;let dw=class extends r.Component{render(){const{items:e,root:t,className:n}=this.props,i=null==this.props.expanded||this.props.expanded;return r.createElement(iv,((e,t)=>{for(var r in t||(t={}))cw.call(t,r)&&pw(e,r,t[r]);if(lw)for(var r of lw(t))uw.call(t,r)&&pw(e,r,t[r]);return e})({className:n,style:this.props.style,$expanded:i},t?{role:"menu"}:{}),e.map((e,t)=>r.createElement(ow,{key:t,item:e,onActivate:this.props.onActivate})))}};function fw(){const[e,t]=(0,r.useState)(!1);return(0,r.useEffect)(()=>{t(!0)},[]),e?r.createElement("img",{alt:"redocly logo",onError:()=>t(!1),src:"https://cdn.redoc.ly/redoc/logo-mini.svg"}):null}dw=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],dw);Object.defineProperty,Object.getOwnPropertyDescriptor;let hw=class extends r.Component{constructor(){super(...arguments),this.activate=e=>{if(e&&e.active&&this.context.menuToggle)return e.expanded?e.collapse():e.expand();this.props.menu.activateAndScroll(e,!0),setTimeout(()=>{this._updateScroll&&this._updateScroll()})},this.saveScrollUpdate=e=>{this._updateScroll=e}}render(){const e=this.props.menu;return r.createElement(df,{updateFn:this.saveScrollUpdate,className:this.props.className,options:{wheelPropagation:!1}},r.createElement(dw,{items:e.items,onActivate:this.activate,root:!0}),r.createElement(cv,null,r.createElement("a",{target:"_blank",rel:"noopener noreferrer",href:"https://redocly.com/redoc/"},r.createElement(fw,null),"API docs by Redocly")))}};hw.contextType=Os,hw=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],hw);const mw=({open:e})=>{const t=e?8:-4;return r.createElement(yw,null,r.createElement(gw,{size:15,style:{transform:`translate(2px, ${t}px) rotate(180deg)`,transition:"transform 0.2s ease"}}),r.createElement(gw,{size:15,style:{transform:`translate(2px, ${0-t}px)`,transition:"transform 0.2s ease"}}))},gw=({size:e=10,className:t="",style:n})=>r.createElement("svg",{className:t,style:n||{},viewBox:"0 0 926.23699 573.74994",version:"1.1",x:"0px",y:"0px",width:e,height:e},r.createElement("g",{transform:"translate(904.92214,-879.1482)"},r.createElement("path",{d:"\n m -673.67664,1221.6502 -231.2455,-231.24803 55.6165,\n -55.627 c 30.5891,-30.59485 56.1806,-55.627 56.8701,-55.627 0.6894,\n 0 79.8637,78.60862 175.9427,174.68583 l 174.6892,174.6858 174.6892,\n -174.6858 c 96.079,-96.07721 175.253196,-174.68583 175.942696,\n -174.68583 0.6895,0 26.281,25.03215 56.8701,\n 55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864\n -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688,\n -104.0616 -231.873,-231.248 z\n ",fill:"currentColor"}))),yw=gs.div` + user-select: none; + width: 20px; + height: 20px; + align-self: center; + display: flex; + flex-direction: column; + color: ${e=>e.theme.colors.primary.main}; +`;Object.defineProperty,Object.getOwnPropertyDescriptor;let bw;Qn&&(bw=n(227));const vw=bw&&bw(),xw=gs.div` + width: ${e=>e.theme.sidebar.width}; + background-color: ${e=>e.theme.sidebar.backgroundColor}; + overflow: hidden; + display: flex; + flex-direction: column; + + backface-visibility: hidden; + /* contain: strict; TODO: breaks layout since Chrome 80*/ + + height: 100vh; + position: sticky; + position: -webkit-sticky; + top: 0; + + ${ms.lessThan("small")` + position: fixed; + z-index: 20; + width: 100%; + background: ${({theme:e})=>e.sidebar.backgroundColor}; + display: ${e=>e.$open?"flex":"none"}; + `}; + + @media print { + display: none; + } +`,ww=gs.div` + outline: none; + user-select: none; + background-color: ${({theme:e})=>e.fab.backgroundColor}; + color: ${e=>e.theme.colors.primary.main}; + display: none; + cursor: pointer; + position: fixed; + right: 20px; + z-index: 100; + border-radius: 50%; + box-shadow: 0 0 20px rgba(0, 0, 0, 0.3); + ${ms.lessThan("small")` + display: flex; + `}; + + bottom: 44px; + + width: 60px; + height: 60px; + padding: 0 20px; + svg { + color: ${({theme:e})=>e.fab.color}; + } + + @media print { + display: none; + } +`;let kw=class extends r.Component{constructor(){super(...arguments),this.state={offsetTop:"0px"},this.toggleNavMenu=()=>{this.props.menu.toggleSidebar()}}componentDidMount(){vw&&vw.add(this.stickyElement),this.setState({offsetTop:this.getScrollYOffset(this.context)})}componentWillUnmount(){vw&&vw.remove(this.stickyElement)}getScrollYOffset(e){let t;return t=void 0!==this.props.scrollYOffset?_i.normalizeScrollYOffset(this.props.scrollYOffset)():e.scrollYOffset(),t+"px"}render(){const e=this.props.menu.sideBarOpened,t=this.state.offsetTop;return r.createElement(r.Fragment,null,r.createElement(xw,{$open:e,className:this.props.className,style:{top:t,height:`calc(100vh - ${t})`},ref:e=>{this.stickyElement=e}},this.props.children),!this.context.hideFab&&r.createElement(ww,{onClick:this.toggleNavMenu},r.createElement(mw,{open:e})))}};kw.contextType=Os,kw=((e,t)=>{for(var r,n=t,i=e.length-1;i>=0;i--)(r=e[i])&&(n=r(n)||n);return n})([Fg],kw);const Sw=gs.div` + ${({theme:e})=>`\n font-family: ${e.typography.fontFamily};\n font-size: ${e.typography.fontSize};\n font-weight: ${e.typography.fontWeightRegular};\n line-height: ${e.typography.lineHeight};\n color: ${e.colors.text.primary};\n display: flex;\n position: relative;\n text-align: left;\n\n -webkit-font-smoothing: ${e.typography.smoothing};\n font-smoothing: ${e.typography.smoothing};\n ${e.typography.optimizeSpeed?"text-rendering: optimizeSpeed !important":""};\n\n tap-highlight-color: rgba(0, 0, 0, 0);\n text-size-adjust: 100%;\n\n * {\n box-sizing: border-box;\n -webkit-tap-highlight-color: rgba(255, 255, 255, 0);\n }\n`}; +`,Ew=gs.div` + z-index: 1; + position: relative; + overflow: hidden; + width: calc(100% - ${e=>e.theme.sidebar.width}); + ${ms.lessThan("small",!0)` + width: 100%; + `}; + + contain: layout; +`,Ow=gs.div` + background: ${({theme:e})=>e.rightPanel.backgroundColor}; + position: absolute; + top: 0; + bottom: 0; + right: 0; + width: ${({theme:e})=>{if(e.rightPanel.width.endsWith("%")){const t=parseInt(e.rightPanel.width,10);return`calc((100% - ${e.sidebar.width}) * ${t/100})`}return e.rightPanel.width}}; + ${ms.lessThan("medium",!0)` + display: none; + `}; +`,_w=gs.div` + padding: 5px 0; +`,Pw=gs.input.attrs(()=>({className:"search-input"}))` + width: calc(100% - ${e=>8*e.theme.spacing.unit}px); + box-sizing: border-box; + margin: 0 ${e=>4*e.theme.spacing.unit}px; + padding: 5px ${e=>2*e.theme.spacing.unit}px 5px + ${e=>4*e.theme.spacing.unit}px; + border: 0; + border-bottom: 1px solid + ${({theme:e})=>(Fn(e.sidebar.backgroundColor)>.5?Dn:Un)(.1,e.sidebar.backgroundColor)}; + font-family: ${({theme:e})=>e.typography.fontFamily}; + font-weight: bold; + font-size: 13px; + color: ${e=>e.theme.sidebar.textColor}; + background-color: transparent; + outline: none; +`,$w=gs(e=>r.createElement("svg",{className:e.className,version:"1.1",viewBox:"0 0 1000 1000",x:"0px",xmlns:"http://www.w3.org/2000/svg",y:"0px"},r.createElement("path",{d:"M968.2,849.4L667.3,549c83.9-136.5,66.7-317.4-51.7-435.6C477.1-25,252.5-25,113.9,113.4c-138.5,138.3-138.5,362.6,0,501C219.2,730.1,413.2,743,547.6,666.5l301.9,301.4c43.6,43.6,76.9,14.9,104.2-12.4C981,928.3,1011.8,893,968.2,849.4z M524.5,522c-88.9,88.7-233,88.7-321.8,0c-88.9-88.7-88.9-232.6,0-321.3c88.9-88.7,233-88.7,321.8,0C613.4,289.4,613.4,433.3,524.5,522z"}))).attrs({className:"search-icon"})` + position: absolute; + left: ${e=>4*e.theme.spacing.unit}px; + height: 1.8em; + width: 0.9em; + + path { + fill: ${e=>e.theme.sidebar.textColor}; + } +`,Aw=gs.div` + padding: ${e=>e.theme.spacing.unit}px 0; + background-color: ${({theme:e})=>Dn(.05,e.sidebar.backgroundColor)}}; + color: ${e=>e.theme.sidebar.textColor}; + min-height: 150px; + max-height: 250px; + border-top: ${({theme:e})=>Dn(.1,e.sidebar.backgroundColor)}}; + border-bottom: ${({theme:e})=>Dn(.1,e.sidebar.backgroundColor)}}; + margin-top: 10px; + line-height: 1.4; + font-size: 0.9em; + + li { + background-color: inherit; + } + + ${av} { + padding-top: 6px; + padding-bottom: 6px; + + &:hover, + &.active { + background-color: ${({theme:e})=>Dn(.1,e.sidebar.backgroundColor)}; + } + + > svg { + display: none; + } + } +`,Cw=gs.i` + position: absolute; + display: inline-block; + width: ${e=>2*e.theme.spacing.unit}px; + text-align: center; + right: ${e=>4*e.theme.spacing.unit}px; + line-height: 2em; + vertical-align: middle; + margin-right: 2px; + cursor: pointer; + font-style: normal; + color: '#666'; +`;var jw=Object.defineProperty,Tw=Object.getOwnPropertyDescriptor;class Nw extends r.PureComponent{constructor(e){super(e),this.activeItemRef=null,this.clear=()=>{this.setState({results:[],noResults:!1,term:"",activeItemIdx:-1}),this.props.marker.unmark()},this.handleKeyDown=e=>{if(27===e.keyCode&&this.clear(),40===e.keyCode&&(this.setState({activeItemIdx:Math.min(this.state.activeItemIdx+1,this.state.results.length-1)}),e.preventDefault()),38===e.keyCode&&(this.setState({activeItemIdx:Math.max(0,this.state.activeItemIdx-1)}),e.preventDefault()),13===e.keyCode){const e=this.state.results[this.state.activeItemIdx];if(e){const t=this.props.getItemById(e.meta);t&&this.props.onActivate(t)}}},this.search=e=>{const{minCharacterLengthToInitSearch:t}=this.context,r=e.target.value;r.lengththis.searchCallback(this.state.term))},this.state={results:[],noResults:!1,term:"",activeItemIdx:-1}}clearResults(e){this.setState({results:[],noResults:!1,term:e}),this.props.marker.unmark()}setResults(e,t){this.setState({results:e,noResults:0===e.length}),this.props.marker.mark(t)}searchCallback(e){this.props.search.search(e).then(t=>{this.setResults(t,e)})}render(){const{activeItemIdx:e}=this.state,t=this.state.results.filter(e=>this.props.getItemById(e.meta)).map(e=>({item:this.props.getItemById(e.meta),score:e.score})).sort((e,t)=>t.score-e.score);return r.createElement(_w,{role:"search"},this.state.term&&r.createElement(Cw,{onClick:this.clear},"×"),r.createElement($w,null),r.createElement(Pw,{value:this.state.term,onKeyDown:this.handleKeyDown,placeholder:"Search...","aria-label":"Search",type:"text",onChange:this.search}),t.length>0&&r.createElement(df,{options:{wheelPropagation:!1}},r.createElement(Aw,{"data-role":"search:results"},t.map((t,n)=>r.createElement(ow,{item:Object.create(t.item,{active:{value:n===e}}),onActivate:this.props.onActivate,withoutChildren:!0,key:t.item.id,"data-role":"search:result"})))),this.state.term&&this.state.noResults?r.createElement(Aw,{"data-role":"search:results"},hi("noResultsFound")):null)}}Nw.contextType=Os,((e,t,r)=>{for(var n,i=Tw(t,r),o=e.length-1;o>=0;o--)(n=e[o])&&(i=n(t,r,i)||i);i&&jw(t,r,i)})([js.bind,(0,js.debounce)(400)],Nw.prototype,"searchCallback");class Iw extends r.Component{componentDidMount(){this.props.store.onDidMount()}componentWillUnmount(){this.props.store.dispose()}render(){const{store:{spec:e,menu:t,options:n,search:i,marker:o}}=this.props,s=this.props.store;return r.createElement(hs,{theme:n.theme},r.createElement(wp,{value:s},r.createElement(_s,{value:n},r.createElement(Sw,{className:"redoc-wrap"},r.createElement(kw,{menu:t,className:"menu-content"},r.createElement(Gb,{info:e.info}),!n.disableSearch&&r.createElement(Nw,{search:i,marker:o,getItemById:t.getItemById,onActivate:t.activateAndScroll})||null,r.createElement(hw,{menu:t})),r.createElement(Ew,{className:"api-content"},r.createElement(qb,{store:s}),r.createElement(Gx,{items:t.items})),r.createElement(Ow,null)))))}}Iw.propTypes={store:Es.instanceOf(Lb).isRequired};var Rw=Object.defineProperty,Lw=Object.getOwnPropertySymbols,Dw=Object.prototype.hasOwnProperty,Mw=Object.prototype.propertyIsEnumerable,zw=(e,t,r)=>t in e?Rw(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Fw=(e,t)=>{for(var r in t||(t={}))Dw.call(t,r)&&zw(e,r,t[r]);if(Lw)for(var r of Lw(t))Mw.call(t,r)&&zw(e,r,t[r]);return e};const Bw=function(e){const{spec:t,specUrl:i,options:o={},onLoaded:s}=e,a=Ei(o.hideLoading,!1),l=new _i(o);if(void 0!==l.nonce)try{n.nc=l.nonce}catch(e){}return r.createElement(vs,null,r.createElement(Sp,{spec:t?Fw({},t):void 0,specUrl:i,options:o,onLoaded:s},({loading:e,store:t})=>e?a?null:r.createElement(Ss,{color:l.theme.colors.primary.main}):r.createElement(Iw,{store:t})))};var Uw=Object.defineProperty,qw=Object.getOwnPropertySymbols,Vw=Object.prototype.hasOwnProperty,Ww=Object.prototype.propertyIsEnumerable,Hw=(e,t,r)=>t in e?Uw(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Gw=(e,t)=>{for(var r in t||(t={}))Vw.call(t,r)&&Hw(e,r,t[r]);if(qw)for(var r of qw(t))Ww.call(t,r)&&Hw(e,r,t[r]);return e};zt({useProxies:"ifavailable"});const Yw="2.5.3",Kw="1b2591e";function Qw(e){const t=function(e){const t={},r=e.attributes;for(let e=0;et.toUpperCase()),i=t[e];r[n]="theme"===e?JSON.parse(i):i}return r}function Xw(e,t={},n=Xn("redoc"),i){if(null===n)throw new Error('"element" argument is not provided and tag is not found on the page');let s,a;"string"==typeof e?s=e:"object"==typeof e&&(a=e),(0,o.H)(n).render(r.createElement(Bw,{spec:a,onLoaded:i,specUrl:s,options:Gw(Gw({},t),Qw(n))},["Loading..."]))}function Jw(e=Xn("redoc")){e&&(0,o.H)(e).unmount()}function Zw(e,t=Xn("redoc"),n){const i=Lb.fromJS(e);setTimeout(()=>{(0,o.c)(t,r.createElement(Iw,{store:i}),{onRecoverableError:n})},0)}!function(){const e=Xn("redoc");if(!e)return;const t=e.getAttribute("spec-url");t&&Xw(t,{},e)}()}(),i}()}); +//# sourceMappingURL=redoc.standalone.js.map \ No newline at end of file diff --git a/lambdas/api/requirements.txt b/lambdas/api/requirements.txt new file mode 100644 index 0000000..10b0d4b --- /dev/null +++ b/lambdas/api/requirements.txt @@ -0,0 +1 @@ +# Dependabot anchor only. The procurement-api Lambda is stdlib+boto3 (provided by the runtime); nothing is pip-installed into the bundle. diff --git a/lambdas/api/router.py b/lambdas/api/router.py new file mode 100644 index 0000000..8bf0539 --- /dev/null +++ b/lambdas/api/router.py @@ -0,0 +1,33 @@ +"""Route tables for the procurement API. + +Single source of truth for what the API implements: the spec-drift test +(tests/test_api_spec_drift.py) asserts these tables match lambdas/api/ +openapi.json exactly, so an endpoint can't be added, removed, or renamed on +one side without failing CI. Keys are (httpMethod, resource) as API Gateway's +Lambda-proxy event presents them (resource = the templated path). + +DATA_ROUTES values are handler-module attribute names resolved by handler.py. +PLANNED_ROUTES are phase-2 write endpoints: present in the spec (x-planned) +and at the gateway, but the handler answers 501 until they ship with their +own IAM diff + cross-family review. +""" + +DATA_ROUTES = { + ("GET", "/work-orders"): "list_work_orders", + ("GET", "/work-orders/{workOrderId}"): "get_work_order", + ("GET", "/work-orders/{workOrderId}/comments"): "list_comments", + ("GET", "/purchase-orders"): "list_purchase_orders", + ("GET", "/purchase-orders/{poNumber}"): "get_purchase_order", + ("GET", "/verified-sites"): "list_verified_sites", + ("GET", "/verified-sites/{siteCode}"): "get_verified_site", +} + +DOCS_ROUTES = { + ("GET", "/docs"), + ("GET", "/openapi.json"), +} + +PLANNED_ROUTES = { + ("POST", "/work-orders/{workOrderId}/comments"), + ("PATCH", "/work-orders/{workOrderId}"), +} diff --git a/lambdas/api/serialization.py b/lambdas/api/serialization.py new file mode 100644 index 0000000..a9271c2 --- /dev/null +++ b/lambdas/api/serialization.py @@ -0,0 +1,43 @@ +"""JSON response helpers for the procurement API. + +DynamoDB items come back through boto3 with numeric attributes as +``decimal.Decimal`` (e.g. purchase-orders ``total_amount``/``line_items`` +prices), which ``json.dumps`` rejects. The encoder below renders integral +Decimals as JSON integers (exact) and non-integral Decimals as floats. For the +values this API serves -- currency amounts at PO magnitudes, well under ~15 +significant digits -- the shortest-float repr round-trips the original digits +exactly. A Decimal carrying more precision than a float can hold (DynamoDB +Number supports 38 digits) would be truncated silently; the pipeline never +writes such values, but if that ever changes, switch non-integral Decimals to +``str(o)`` and update the OpenAPI number types. +""" + +import decimal +import json + + +class _DecimalSafeEncoder(json.JSONEncoder): + def default(self, o): + if isinstance(o, decimal.Decimal): + if o == o.to_integral_value(): + return int(o) + return float(o) + if isinstance(o, set): + return sorted(o) + return super().default(o) + + +def dumps(payload) -> str: + return json.dumps(payload, cls=_DecimalSafeEncoder) + + +def json_response(status_code: int, payload) -> dict: + return { + "statusCode": status_code, + "headers": {"Content-Type": "application/json"}, + "body": dumps(payload), + } + + +def error_response(status_code: int, message: str) -> dict: + return json_response(status_code, {"error": message}) diff --git a/lambdas/api/wo_repo.py b/lambdas/api/wo_repo.py new file mode 100644 index 0000000..3521468 --- /dev/null +++ b/lambdas/api/wo_repo.py @@ -0,0 +1,62 @@ +"""Read access to the work-order tables for the procurement API. + +Listing is a cursor-paginated Scan -- deliberately: the WO tables carry no +GSIs (removed 2026-06-03 for zero reads), and the API's list consumers +(SHOC reconciliation/backfill) walk the full table anyway, which is exactly +the access pattern SHOC's retired SyncController used. Listings are therefore +UNORDERED across pages; per-work-order comment listing is a cheap Query on +the partition key. +""" + +import os + +import boto3 +from boto3.dynamodb.conditions import Key + +from pagination import BadCursor, decode_cursor, encode_cursor + +dynamodb = boto3.resource("dynamodb") + +WORK_ORDERS_TABLE = os.environ.get("WORK_ORDERS_TABLE", "WorkOrders") +COMMENTS_TABLE = os.environ.get("COMMENTS_TABLE", "WorkOrderComments") + +WO_KEY_ATTRS = frozenset({"work_order_id"}) +COMMENT_KEY_ATTRS = frozenset({"work_order_id", "comment_id"}) + + +def _page(response) -> tuple[list, str | None]: + items = response.get("Items", []) + lek = response.get("LastEvaluatedKey") + return items, (encode_cursor(lek) if lek else None) + + +def list_work_orders(limit: int, cursor: str | None) -> tuple[list, str | None]: + table = dynamodb.Table(WORK_ORDERS_TABLE) + kwargs = {"Limit": limit} + if cursor: + kwargs["ExclusiveStartKey"] = decode_cursor(cursor, WO_KEY_ATTRS) + return _page(table.scan(**kwargs)) + + +def get_work_order(work_order_id: str) -> dict | None: + table = dynamodb.Table(WORK_ORDERS_TABLE) + return table.get_item(Key={"work_order_id": work_order_id}).get("Item") + + +def list_comments( + work_order_id: str, limit: int, cursor: str | None +) -> tuple[list, str | None]: + table = dynamodb.Table(COMMENTS_TABLE) + kwargs = { + "KeyConditionExpression": Key("work_order_id").eq(work_order_id), + "Limit": limit, + } + if cursor: + start_key = decode_cursor(cursor, COMMENT_KEY_ATTRS) + # Pin the cursor's partition to the path entity: a cursor minted for + # WO A must never resume WO B's Query (DynamoDB would reject the + # partition mismatch as a 500; reject it as a 400 here instead). + if start_key["work_order_id"] != work_order_id: + raise BadCursor("cursor is not valid") + kwargs["ExclusiveStartKey"] = start_key + return _page(table.query(**kwargs)) diff --git a/lambdas/shared/web_ui_auth.py b/lambdas/shared/web_ui_auth.py index 4b2d245..0359298 100644 --- a/lambdas/shared/web_ui_auth.py +++ b/lambdas/shared/web_ui_auth.py @@ -74,4 +74,8 @@ def is_authenticated(event: dict) -> bool: presented = auth[7:].strip() if not presented: return False - return hmac.compare_digest(presented, token) + # Compare as bytes: hmac.compare_digest raises TypeError on non-ASCII str + # operands, which a crafted token (?token=%C3%A9 or a non-ASCII header) + # would otherwise turn into an uncaught 500. Bytes always compare in + # constant time, so a non-matching token fails closed (401) instead. + return hmac.compare_digest(presented.encode("utf-8"), token.encode("utf-8")) diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..d3aacda --- /dev/null +++ b/package-lock.json @@ -0,0 +1,27 @@ +{ + "name": "procurement-ingest", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "devDependencies": { + "@redocly/cli": "^2.40.0" + } + }, + "node_modules/@redocly/cli": { + "version": "2.40.0", + "resolved": "https://registry.npmjs.org/@redocly/cli/-/cli-2.40.0.tgz", + "integrity": "sha512-1uQ4GeNjhApy9EtypZgp70ZN5GC2JFfst3UkNEXSqkXgVIPGdEAnlz5Xwgax/4cEUGOvaZoM3X25iSQcqbplFg==", + "dev": true, + "license": "MIT", + "bin": { + "openapi": "bin/cli.js", + "redocly": "bin/cli.js" + }, + "engines": { + "node": ">=22.12.0 || >=20.19.0 <21.0.0", + "npm": ">=10" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..d4f1d69 --- /dev/null +++ b/package.json @@ -0,0 +1,9 @@ +{ + "scripts": { + "lint:api": "redocly lint lambdas/api/openapi.json --config=redocly.yaml", + "docs:preview": ".venv/bin/python scripts/preview_docs.py" + }, + "devDependencies": { + "@redocly/cli": "^2.40.0" + } +} diff --git a/pytest.ini b/pytest.ini index 9511b4a..1bacae8 100644 --- a/pytest.ini +++ b/pytest.ini @@ -12,6 +12,7 @@ addopts = --cov=lambdas/po/web_ui --cov=lambdas/wo/web_ui --cov=lambdas/po/site_extractor + --cov=lambdas/api --cov=lambdas/shared --cov-report=term-missing --cov-fail-under=80 diff --git a/redocly.yaml b/redocly.yaml new file mode 100644 index 0000000..107d2b9 --- /dev/null +++ b/redocly.yaml @@ -0,0 +1,122 @@ +extends: + - recommended +rules: + # Proprietary internal license -- no SPDX identifier or public URL exists. + info-license-strict: off + rule/info-title-api: + subject: + type: Info + property: title + assertions: + pattern: /.*API.*/ + rule/info-description: + subject: + type: Info + property: description + assertions: + defined: true + operation-4xx-response: error + # Off: the live contract is {"error": string} as plain application/json + # (serialization.py error_response). Adopting RFC 7807 would be a runtime + # + SHOC-contract change, decided against 2026-07-24. + operation-4xx-problem-details-rfc7807: off + operation-operationId: error + rule/operationId-casing: + subject: + type: Operation + property: operationId + assertions: + casing: kebab-case + rule/operationId-prefix: + subject: + type: Operation + property: operationId + assertions: + pattern: /^GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE/i + rule/operation-summary-period: + subject: + type: Operation + property: summary + assertions: + pattern: /[^.]$/ + path-not-include-query: error + # No parameter-casing rule: path parameter names (workOrderId, poNumber, + # siteCode) are camelCase by contract -- they are baked into the API Gateway + # resource paths and read by the handler's pathParameters lookup. + rule/params-must-include-examples: + severity: error + subject: + type: Parameter + assertions: + requireAny: + - example + - examples + no-http-verbs-in-paths: error + no-ambiguous-paths: error + path-segment-plural: + severity: error + exceptions: + - docs + - openapi.json + paths-kebab-case: error + no-invalid-schema-examples: error + # No schema-properties casing rule: property names mirror the DynamoDB + # items and the shipped SHOC webhook contract -- snake_case for WO/PO + # tables, camelCase for verified-sites (legacy, issue #24). Not lintable + # to one casing without a contract break. + # Error bodies must carry the top-level "error" field (the Error schema). + # 403 is exempt: it is emitted by API Gateway's SigV4 layer with AWS's + # {"message"} shape, not by the Lambda. + response-contains-property: + severity: error + names: + '400': + - error + '401': + - error + '404': + - error + '501': + - error + request-mime-type: + severity: error + allowedValues: + - application/json + response-mime-type: + severity: error + allowedValues: + - application/json + - text/html + no-server-example.com: error + rule/no-server-localhost: + subject: + type: Server + property: url + assertions: + notPattern: /(localhost|127.0.0.1) + operation-singular-tag: error + operation-tag-defined: error + rule/tag-description: + subject: + type: Tag + property: description + assertions: + defined: true + rule/description-capitalization: + subject: + type: any + property: description + assertions: + pattern: /^([A-Z]|true|seahaven-prod)/ + rule/description-punctuation: + subject: + type: any + property: description + assertions: + pattern: /(\.|server)$/ + rule/avoid-words-in-descriptions: + subject: + type: any + property: description + assertions: + notPattern: /(simply|easy|easily|just|obviously|notethat)/i diff --git a/scripts/post-deploy-smoke.sh b/scripts/post-deploy-smoke.sh index 9daffc2..5988a19 100755 --- a/scripts/post-deploy-smoke.sh +++ b/scripts/post-deploy-smoke.sh @@ -14,7 +14,7 @@ set -euo pipefail REGION="us-east-1" -FUNCTION_NAMES=("po-email-processor" "workorder-email-processor") +FUNCTION_NAMES=("po-email-processor" "workorder-email-processor" "procurement-api") HEALTHCHECK_PAYLOAD='{"healthcheck": true}' work_dir="$(mktemp -d)" diff --git a/scripts/preview_docs.py b/scripts/preview_docs.py new file mode 100644 index 0000000..931b6cc --- /dev/null +++ b/scripts/preview_docs.py @@ -0,0 +1,34 @@ +"""Render the /docs page locally and open it in the default browser. + +Goes through the real handler code path (vendored Redoc bundle + fonts +inlined, breakout guards applied, spec spliced), so the preview is +byte-identical to what the Lambda serves, minus the token gate. No AWS +credentials or network needed; without a request context the spec keeps +its committed fallback server URL. + +Run from the repo root: `npm run docs:preview` (or +`.venv/bin/python scripts/preview_docs.py`). +""" + +import sys +import tempfile +import webbrowser +from pathlib import Path + +REPO_ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(REPO_ROOT)) + +from tests.support import load_lambda_module # noqa: E402 + + +def main() -> None: + handler = load_lambda_module("api", "handler") + html = handler._render_docs_html({}) + out = Path(tempfile.gettempdir()) / "procurement-docs-preview.html" + out.write_text(html, encoding="utf-8") + print(f"wrote {out} ({len(html)} bytes)") + webbrowser.open(out.as_uri()) + + +if __name__ == "__main__": + main() diff --git a/tests/support/loader.py b/tests/support/loader.py index a826b78..ad959aa 100644 --- a/tests/support/loader.py +++ b/tests/support/loader.py @@ -50,6 +50,15 @@ _SIBLING_MODULES = ( "email_parsing", "emf", "web_ui_auth", + # procurement-api siblings (lambdas/api/): pagination/serialization/router + # have no sibling deps; wo_repo/po_repo import pagination, so they follow + # it. These names exist only under lambdas/api/, so the po/wo handler + # loads skip them via the exists() check. + "pagination", + "serialization", + "router", + "wo_repo", + "po_repo", "prompts", "template_parser", "derived_fields", diff --git a/tests/test_api_handlers.py b/tests/test_api_handlers.py new file mode 100644 index 0000000..fdf1c5f --- /dev/null +++ b/tests/test_api_handlers.py @@ -0,0 +1,280 @@ +"""procurement-api handler tests (offline, fake Dynamo). + +Pins the auth seam both ways: docs routes fail closed on the shared token +(including the browser ?token= shim), while data routes must NOT consult the +token at all -- SigV4 authorization is API Gateway's job upstream, and a +handler-side token check there would break every legitimate SigV4 caller. +Also pins routing, 404/501/400 mapping, Decimal-safe serialization, and limit +clamping. +""" + +import json +from decimal import Decimal + +import pytest + +from tests.support import load_lambda_module + + +class _FakeTable: + def __init__(self, items): + self._items = items + self.last_kwargs = None + + def scan(self, **kwargs): + self.last_kwargs = kwargs + return {"Items": list(self._items)} + + def query(self, **kwargs): + self.last_kwargs = kwargs + return {"Items": list(self._items)} + + def get_item(self, Key): # noqa: N803 (boto3 kwarg name) + pk_attr, pk_val = next(iter(Key.items())) + for item in self._items: + if item.get(pk_attr) == pk_val: + return {"Item": item} + return {} + + +class _FakeDynamo: + def __init__(self, tables): + self.tables = tables + + def Table(self, name): # noqa: N802 (boto3 method name) + return self.tables[name] + + +def _event(method, resource, path_params=None, qs=None, headers=None): + return { + "httpMethod": method, + "resource": resource, + "pathParameters": path_params or {}, + "queryStringParameters": qs or {}, + "headers": headers or {}, + } + + +@pytest.fixture() +def api(monkeypatch): + mod = load_lambda_module("api", "handler") + wo_items = [ + { + "work_order_id": "11144580730", + "wo_status": "assigned", + "description": "Dock door 14", + } + ] + comment_items = [ + { + "work_order_id": "11144580730", + "comment_id": "11144580730#2026-01-01T00:00:00#abc123def456", + "text": "Vendor dispatched", + } + ] + po_items = [ + { + "po_number": "2D-22030794", + "total_amount": Decimal("123.45"), + "line_items": [{"quantity": Decimal("5"), "price": Decimal("24.69")}], + } + ] + site_items = [{"siteCode": "JFK8", "state": "NY", "poCount": Decimal("7")}] + + tables = { + mod.wo_repo.WORK_ORDERS_TABLE: _FakeTable(wo_items), + mod.wo_repo.COMMENTS_TABLE: _FakeTable(comment_items), + mod.po_repo.PO_TABLE: _FakeTable(po_items), + mod.po_repo.VERIFIED_SITES_TABLE: _FakeTable(site_items), + } + fake = _FakeDynamo(tables) + monkeypatch.setattr(mod.wo_repo, "dynamodb", fake) + monkeypatch.setattr(mod.po_repo, "dynamodb", fake) + return mod, fake + + +def test_healthcheck_short_circuits(api): + mod, _ = api + assert mod.handler({"healthcheck": True}, None) == {"healthcheck": "ok"} + + +def test_docs_fail_closed_without_token(api): + # No WEB_UI_AUTH_TOKEN_SECRET_ARN configured -> web_ui_auth returns None + # -> the docs routes must 401, not serve the spec. + mod, _ = api + for resource in ("/docs", "/openapi.json"): + response = mod.handler(_event("GET", resource), None) + assert response["statusCode"] == 401 + + +def test_docs_served_when_authenticated(api, monkeypatch): + mod, _ = api + monkeypatch.setattr(mod, "is_authenticated", lambda event: True) + docs = mod.handler(_event("GET", "/docs"), None) + assert docs["statusCode"] == 200 + assert docs["headers"]["Content-Type"].startswith("text/html") + # The vendored Redoc bundle is inlined and the spec (carrying the title) + # with it. + assert "Redoc.init" in docs["body"] + assert "Procurement Ingest API" in docs["body"] + # Every placeholder must be substituted, or the page renders broken. + for placeholder in ( + mod._SPEC_PLACEHOLDER, + mod._JS_PLACEHOLDER, + mod._FONTS_PLACEHOLDER, + ): + assert placeholder not in docs["body"] + + spec = mod.handler(_event("GET", "/openapi.json"), None) + assert spec["statusCode"] == 200 + assert json.loads(spec["body"])["openapi"] == "3.1.0" + + +def test_token_query_shim_synthesizes_header(api, monkeypatch): + mod, _ = api + seen = {} + + def capture(event): + seen.update(event.get("headers") or {}) + return False + + monkeypatch.setattr(mod, "is_authenticated", capture) + original = _event("GET", "/docs", qs={"token": "sekrit"}) + mod.handler(original, None) + assert seen.get("x-auth-token") == "sekrit" + # The shim must not mutate the caller's event in place. + assert "x-auth-token" not in original["headers"] + + +def test_non_ascii_token_fails_closed_not_500(api): + # A non-ASCII presented token must 401 (fail closed), not crash + # hmac.compare_digest into a 500 that pages the 5xx alarm. Reach the + # web_ui_auth module namespace through the imported is_authenticated's + # globals and seed a valid cached token. + mod, _ = api + auth_globals = mod.is_authenticated.__globals__ + auth_globals["_auth_token_cache"] = "correct-token" + auth_globals["_auth_token_cached_at"] = float("inf") + try: + response = mod.handler( + _event("GET", "/docs", headers={"x-auth-token": "é"}), None + ) + assert response["statusCode"] == 401 + finally: + auth_globals["_auth_token_cache"] = None + auth_globals["_auth_token_cached_at"] = 0.0 + + +def test_data_routes_never_consult_docs_token(api, monkeypatch): + mod, _ = api + + def explode(event): + raise AssertionError("data routes must not consult the docs token") + + monkeypatch.setattr(mod, "is_authenticated", explode) + response = mod.handler(_event("GET", "/work-orders"), None) + assert response["statusCode"] == 200 + + +def test_list_and_get_routing(api): + mod, _ = api + listing = mod.handler(_event("GET", "/work-orders"), None) + body = json.loads(listing["body"]) + assert body["items"][0]["work_order_id"] == "11144580730" + assert body["next_cursor"] is None + + hit = mod.handler( + _event( + "GET", + "/work-orders/{workOrderId}", + path_params={"workOrderId": "11144580730"}, + ), + None, + ) + assert json.loads(hit["body"])["wo_status"] == "assigned" + + miss = mod.handler( + _event( + "GET", + "/work-orders/{workOrderId}", + path_params={"workOrderId": "999"}, + ), + None, + ) + assert miss["statusCode"] == 404 + + comments = mod.handler( + _event( + "GET", + "/work-orders/{workOrderId}/comments", + path_params={"workOrderId": "11144580730"}, + ), + None, + ) + assert json.loads(comments["body"])["items"][0]["text"] == "Vendor dispatched" + + sites = mod.handler( + _event( + "GET", + "/verified-sites/{siteCode}", + path_params={"siteCode": "JFK8"}, + ), + None, + ) + assert json.loads(sites["body"])["state"] == "NY" + + +def test_decimal_serialization_round_trips(api): + mod, _ = api + response = mod.handler( + _event( + "GET", + "/purchase-orders/{poNumber}", + path_params={"poNumber": "2D-22030794"}, + ), + None, + ) + body = json.loads(response["body"]) + assert body["total_amount"] == 123.45 + assert body["line_items"][0]["quantity"] == 5 + assert isinstance(body["line_items"][0]["quantity"], int) + assert "Decimal" not in response["body"] + + +def test_limit_clamped_to_bounds(api): + mod, fake = api + mod.handler(_event("GET", "/work-orders", qs={"limit": "9999"}), None) + assert fake.tables[mod.wo_repo.WORK_ORDERS_TABLE].last_kwargs["Limit"] == 500 + mod.handler(_event("GET", "/work-orders", qs={"limit": "0"}), None) + assert fake.tables[mod.wo_repo.WORK_ORDERS_TABLE].last_kwargs["Limit"] == 1 + + +def test_non_integer_limit_is_400(api): + mod, _ = api + response = mod.handler(_event("GET", "/work-orders", qs={"limit": "abc"}), None) + assert response["statusCode"] == 400 + + +def test_planned_routes_return_501(api): + mod, _ = api + for method, resource in mod.PLANNED_ROUTES: + response = mod.handler(_event(method, resource), None) + assert response["statusCode"] == 501, (method, resource) + + +def test_unknown_route_is_404(api): + mod, _ = api + response = mod.handler(_event("GET", "/nope"), None) + assert response["statusCode"] == 404 + + +def test_unexpected_error_maps_to_clean_500(api, monkeypatch): + mod, fake = api + + def boom(**kwargs): + raise RuntimeError("dynamo fell over") + + monkeypatch.setattr(fake.tables[mod.wo_repo.WORK_ORDERS_TABLE], "scan", boom) + response = mod.handler(_event("GET", "/work-orders"), None) + assert response["statusCode"] == 500 + assert json.loads(response["body"]) == {"error": "internal error"} diff --git a/tests/test_api_pagination_moto.py b/tests/test_api_pagination_moto.py new file mode 100644 index 0000000..10584ec --- /dev/null +++ b/tests/test_api_pagination_moto.py @@ -0,0 +1,232 @@ +"""Cursor pagination against real DynamoDB semantics (moto). + +The offline handler tests fake Dynamo, which can't exercise real +LastEvaluatedKey behavior. Here moto-backed tables with the production key +schemas prove: pages are disjoint and complete, the final page's next_cursor +is null, comment Query pagination respects the composite key, and hostile +cursors (garbage, wrong key attrs, huge) map to 400 -- never 500, never a raw +ExclusiveStartKey error. + +The repo modules build their boto3 resource at import time; a resource created +before mock_aws starts is NOT intercepted, so each test rebinds the modules' +``dynamodb`` to a fresh resource inside the mock (same trap as test_po_merge's +moto-before-handler ordering). +""" + +import base64 +import json + +import boto3 +import pytest +from moto import mock_aws + +from tests.support import load_lambda_module + + +def _event(method, resource, path_params=None, qs=None): + return { + "httpMethod": method, + "resource": resource, + "pathParameters": path_params or {}, + "queryStringParameters": qs or {}, + "headers": {}, + } + + +@pytest.fixture() +def api(monkeypatch): + with mock_aws(): + mod = load_lambda_module("api", "handler") + resource = boto3.resource("dynamodb", region_name="us-east-1") + monkeypatch.setattr(mod.wo_repo, "dynamodb", resource) + monkeypatch.setattr(mod.po_repo, "dynamodb", resource) + + resource.create_table( + TableName=mod.wo_repo.WORK_ORDERS_TABLE, + KeySchema=[{"AttributeName": "work_order_id", "KeyType": "HASH"}], + AttributeDefinitions=[ + {"AttributeName": "work_order_id", "AttributeType": "S"} + ], + BillingMode="PAY_PER_REQUEST", + ) + resource.create_table( + TableName=mod.wo_repo.COMMENTS_TABLE, + KeySchema=[ + {"AttributeName": "work_order_id", "KeyType": "HASH"}, + {"AttributeName": "comment_id", "KeyType": "RANGE"}, + ], + AttributeDefinitions=[ + {"AttributeName": "work_order_id", "AttributeType": "S"}, + {"AttributeName": "comment_id", "AttributeType": "S"}, + ], + BillingMode="PAY_PER_REQUEST", + ) + resource.create_table( + TableName=mod.po_repo.PO_TABLE, + KeySchema=[{"AttributeName": "po_number", "KeyType": "HASH"}], + AttributeDefinitions=[{"AttributeName": "po_number", "AttributeType": "S"}], + BillingMode="PAY_PER_REQUEST", + ) + resource.create_table( + TableName=mod.po_repo.VERIFIED_SITES_TABLE, + KeySchema=[{"AttributeName": "siteCode", "KeyType": "HASH"}], + AttributeDefinitions=[{"AttributeName": "siteCode", "AttributeType": "S"}], + BillingMode="PAY_PER_REQUEST", + ) + yield mod, resource + + +def _walk_pages(mod, resource_path, qs_extra=None, path_params=None, limit=5): + seen, pages = [], 0 + cursor = None + while True: + qs = {"limit": str(limit), **(qs_extra or {})} + if cursor: + qs["cursor"] = cursor + response = mod.handler( + _event("GET", resource_path, path_params=path_params, qs=qs), None + ) + assert response["statusCode"] == 200 + body = json.loads(response["body"]) + seen.extend(body["items"]) + pages += 1 + cursor = body["next_cursor"] + assert pages < 50, "pagination failed to terminate" + if cursor is None: + return seen, pages + + +def test_work_order_scan_pages_are_disjoint_and_complete(api): + mod, resource = api + table = resource.Table(mod.wo_repo.WORK_ORDERS_TABLE) + for i in range(12): + table.put_item(Item={"work_order_id": str(10000 + i), "wo_status": "new"}) + + items, pages = _walk_pages(mod, "/work-orders", limit=5) + ids = [item["work_order_id"] for item in items] + assert len(ids) == 12 + assert len(set(ids)) == 12 + assert pages >= 3 + + +def test_comment_query_pagination_composite_key(api): + mod, resource = api + table = resource.Table(mod.wo_repo.COMMENTS_TABLE) + for i in range(7): + table.put_item( + Item={ + "work_order_id": "555", + "comment_id": f"555#2026-01-0{i + 1}T00:00:00#{i:012d}", + "text": f"comment {i}", + } + ) + # A second work order's comments must never bleed into the page. + table.put_item( + Item={"work_order_id": "666", "comment_id": "666#x#0", "text": "other"} + ) + + items, _ = _walk_pages( + mod, + "/work-orders/{workOrderId}/comments", + path_params={"workOrderId": "555"}, + limit=3, + ) + assert len(items) == 7 + assert {item["work_order_id"] for item in items} == {"555"} + + +def test_purchase_order_and_site_pagination(api): + mod, resource = api + po_table = resource.Table(mod.po_repo.PO_TABLE) + for i in range(6): + po_table.put_item(Item={"po_number": f"2D-{i:08d}"}) + sites_table = resource.Table(mod.po_repo.VERIFIED_SITES_TABLE) + for code in ("JFK8", "WNY2", "UVA5"): + sites_table.put_item(Item={"siteCode": code}) + + po_items, _ = _walk_pages(mod, "/purchase-orders", limit=4) + assert len(po_items) == 6 + site_items, _ = _walk_pages(mod, "/verified-sites", limit=2) + assert {item["siteCode"] for item in site_items} == {"JFK8", "WNY2", "UVA5"} + + +@pytest.mark.parametrize( + "cursor", + [ + "not-base64!!!", + "aGVsbG8=", # base64("hello") -- not JSON-dict + "e30=", # base64("{}") -- empty dict + # base64 of {"evil_attr": "x"} -- key attr not allowed for this table + "eyJldmlsX2F0dHIiOiAieCJ9", + "A" * 3000, # oversized + ], +) +def test_hostile_cursor_is_400_not_500(api, cursor): + mod, resource = api + resource.Table(mod.wo_repo.WORK_ORDERS_TABLE).put_item(Item={"work_order_id": "1"}) + response = mod.handler(_event("GET", "/work-orders", qs={"cursor": cursor}), None) + assert response["statusCode"] == 400 + assert "error" in json.loads(response["body"]) + + +def _cursor(payload): + return base64.urlsafe_b64encode(json.dumps(payload).encode()).decode() + + +def test_partial_composite_cursor_is_400_not_500(api): + # A work-orders-shaped cursor {work_order_id} is a partial key for the + # comments Query (needs work_order_id+comment_id). Exact-key match rejects + # it as 400 rather than letting DynamoDB ValidationException -> 500. + mod, resource = api + resource.Table(mod.wo_repo.COMMENTS_TABLE).put_item( + Item={"work_order_id": "555", "comment_id": "555#x#0"} + ) + response = mod.handler( + _event( + "GET", + "/work-orders/{workOrderId}/comments", + path_params={"workOrderId": "555"}, + qs={"cursor": _cursor({"work_order_id": "555"})}, + ), + None, + ) + assert response["statusCode"] == 400 + + +def test_cross_work_order_comment_cursor_is_400(api): + # A full comments cursor minted for WO A must not resume WO B's Query. + mod, resource = api + response = mod.handler( + _event( + "GET", + "/work-orders/{workOrderId}/comments", + path_params={"workOrderId": "B"}, + qs={"cursor": _cursor({"work_order_id": "A", "comment_id": "A#x#0"})}, + ), + None, + ) + assert response["statusCode"] == 400 + + +def test_dynamodb_validation_error_maps_to_400(api, monkeypatch): + # Defense in depth: even if some crafted-but-valid cursor reached DynamoDB + # and raised ValidationException, the handler maps it to 400, not a 500 + # that would page the zero-threshold 5xx alarm. + from botocore.exceptions import ClientError + + mod, _ = api + + class _RaisingTable: + def scan(self, **kwargs): + raise ClientError( + {"Error": {"Code": "ValidationException", "Message": "bad key"}}, + "Scan", + ) + + monkeypatch.setattr( + mod.wo_repo, + "dynamodb", + type("D", (), {"Table": lambda self, n: _RaisingTable()})(), + ) + response = mod.handler(_event("GET", "/work-orders"), None) + assert response["statusCode"] == 400 diff --git a/tests/test_api_spec_drift.py b/tests/test_api_spec_drift.py new file mode 100644 index 0000000..54f1f1d --- /dev/null +++ b/tests/test_api_spec_drift.py @@ -0,0 +1,131 @@ +"""Spec <-> implementation drift gate. + +lambdas/api/openapi.json is the published contract; lambdas/api/router.py is +what the Lambda actually serves. This test makes them the SAME set: an +endpoint added/removed/renamed on one side without the other fails CI here, +so the docs page can never silently lie. Also pins the phase-2 x-planned +markers, the four outbound webhook events, and the enum values the spec +promises against the WO extraction contract (prompts.py). +""" + +import json +from pathlib import Path + +from tests.support import REPO_ROOT, load_lambda_module + +_SPEC_PATH = Path(REPO_ROOT) / "lambdas" / "api" / "openapi.json" + +_HTTP_METHODS = {"get", "put", "post", "patch", "delete", "head", "options"} + + +def _spec(): + return json.loads(_SPEC_PATH.read_text(encoding="utf-8")) + + +def _spec_routes(spec): + implemented, planned = set(), set() + for path, ops in spec["paths"].items(): + for method, op in ops.items(): + if method not in _HTTP_METHODS: + continue + key = (method.upper(), path) + if op.get("x-planned"): + planned.add(key) + else: + implemented.add(key) + return implemented, planned + + +def test_spec_is_openapi_31(): + assert _spec()["openapi"] == "3.1.0" + + +def test_implemented_routes_match_router_exactly(): + router = load_lambda_module("api", "router") + implemented, planned = _spec_routes(_spec()) + assert implemented == set(router.DATA_ROUTES) | set(router.DOCS_ROUTES) + assert planned == set(router.PLANNED_ROUTES) + + +def test_every_data_route_has_a_repo_function(): + router = load_lambda_module("api", "router") + handler = load_lambda_module("api", "handler") + assert set(router.DATA_ROUTES.values()) == set(handler._REPO_FUNCS) + + +def test_webhooks_section_documents_all_four_events(): + spec = _spec() + assert set(spec["webhooks"]) == { + "work_order.created", + "work_order.updated", + "work_order.cancelled", + "work_order.comment_added", + } + for ops in spec["webhooks"].values(): + assert "post" in ops + + +def test_spec_enums_match_wo_extraction_contract(): + # The WO pipeline's prompts.py is the enum source of truth (the webhook + # contract pins it too). If the pipeline ever widens wo_status or + # record_type, the published spec must move in the same PR. + prompts = load_lambda_module("wo", "email_processor/prompts") + prompt_text = prompts.EXTRACTION_PROMPT + spec = _spec() + schemas = spec["components"]["schemas"] + + wo_status_enum = { + value + for value in schemas["WorkOrder"]["properties"]["wo_status"]["enum"] + if value is not None + } + record_type_enum = { + value + for value in schemas["WorkOrder"]["properties"]["record_type"]["enum"] + if value is not None + } + for value in wo_status_enum - {"unknown"}: + assert value in prompt_text, f"wo_status {value!r} not in extraction prompt" + for value in record_type_enum: + assert value in prompt_text, f"record_type {value!r} not in extraction prompt" + + event_data = schemas["WorkOrderEventData"]["properties"] + assert set(event_data["wo_status"]["enum"]) == set( + schemas["WorkOrder"]["properties"]["wo_status"]["enum"] + ) + + +def test_spec_has_no_script_breakout_sequence(): + # The spec is inlined into a /: each is inlined + # into a