@graph8/sdk 0.251.0 → 0.262.0

package/docs/api/skills.d.ts

@@ -0,0 +1,230 @@
+/* Generated by sdk/js/scripts/generate-agent-docs.ts from developer-contract/openapi.json. Regenerated on every build. */
+
+/**
+ * Types for `g8.api.skills` (Skills): 12 operations.
+ *
+ * For reading. In code, import from the package instead:
+ *   import type { ApiInput, ApiOutput, G8Contract } from "@graph8/sdk";
+ *   type In = ApiInput<"create_from_node_skills_from_node_post">;
+ *
+ * Reference with examples: skills.md
+ */
+/* eslint-disable */
+
+/** `g8.api.skills.<member>` -> the operationId it calls. */
+export interface SkillsMembers {
+  createFromNode: "create_from_node_skills_from_node_post";
+  createFromTemplate: "create_from_template_skills_from_template_post";
+  createSkill: "create_skill_skills_post";
+  deleteSkill: "delete_skill_skills__action_id__delete";
+  executeSkill: "execute_skill_skills__action_id__execute_post";
+  extractVariables: "extract_variables_skills__action_id__variables_get";
+  getSkill: "get_skill_skills__action_id__get";
+  listModels: "list_models_skills_models_get";
+  listSkills: "list_skills_skills_get";
+  listTemplates: "list_templates_skills_templates_get";
+  updateSkill: "update_skill_skills__action_id__put";
+  validateTemplate: "validate_template_skills_validate_post";
+}
+
+/** Input and output of every `g8.api.skills` operation, keyed by operationId. */
+export interface SkillsOperations {
+  /**
+   * POST /skills/from-node
+   * Lift a workflow action node into a standalone skill
+   * tier: write · scope: workflows:write
+   */
+  create_from_node_skills_from_node_post: {
+    input: {
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * POST /skills/from-template
+   * Create a skill from a template
+   * tier: write · scope: workflows:write
+   */
+  create_from_template_skills_from_template_post: {
+    input: {
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * POST /skills
+   * Create a skill (LLM or API runtime)
+   * tier: write · scope: workflows:write
+   */
+  create_skill_skills_post: {
+    input: {
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * DELETE /skills/{action_id}
+   * Delete a skill
+   * tier: destructive · scope: workflows:delete
+   */
+  delete_skill_skills__action_id__delete: {
+    input: {
+    path: {
+      /** Skill action_id. */
+      action_id: string;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * POST /skills/{action_id}/execute
+   * Execute a skill once
+   * tier: external · scope: workflows:run
+   */
+  execute_skill_skills__action_id__execute_post: {
+    input: {
+    path: {
+      /** Skill action_id. */
+      action_id: string;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body?: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * GET /skills/{action_id}/variables
+   * Extract {variable} placeholders from a skill's templates
+   * tier: read · scope: workflows:read
+   */
+  extract_variables_skills__action_id__variables_get: {
+    input: {
+    path: {
+      /** Skill action_id. */
+      action_id: string;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * GET /skills/{action_id}
+   * Get a skill's full configuration
+   * tier: read · scope: workflows:read
+   */
+  get_skill_skills__action_id__get: {
+    input: {
+    path: {
+      /** Skill action_id. */
+      action_id: string;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * GET /skills/models
+   * List supported LLM model identifiers
+   * tier: read · scope: workflows:read
+   */
+  list_models_skills_models_get: {
+    input: {
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * GET /skills
+   * List skills (LLM + API) for the caller's org
+   * tier: read · scope: workflows:read
+   */
+  list_skills_skills_get: {
+    input: {
+    query?: {
+      /** Filter to a single runtime (llm or api). Omit to see both. */
+      runtime_type?: string | null;
+      /** Filter by enabled flag. */
+      enabled?: boolean | null;
+      /** Filter by category. */
+      category?: string | null;
+      /** Filter by entity type the skill targets. */
+      object_type?: string | null;
+      /** Include shared system-default skills alongside org-owned ones. */
+      include_system?: boolean;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * GET /skills/templates
+   * List skill templates
+   * tier: read · scope: workflows:read
+   */
+  list_templates_skills_templates_get: {
+    input: {
+    query?: {
+      /** Filter by category. */
+      category?: string | null;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * PUT /skills/{action_id}
+   * Update a skill
+   * tier: write · scope: workflows:write
+   */
+  update_skill_skills__action_id__put: {
+    input: {
+    path: {
+      /** Skill action_id. */
+      action_id: string;
+    };
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+  /**
+   * POST /skills/validate
+   * Validate a skill template (extract + warn on common mistakes)
+   * tier: write · scope: workflows:write
+   */
+  validate_template_skills_validate_post: {
+    input: {
+    headers?: {
+      "X-Target-Org-Id"?: string | null;
+    };
+    body: Record<string, unknown>;
+  };
+    output: Record<string, unknown>;
+  };
+}

package/docs/api/skills.md

@@ -0,0 +1,466 @@
+<!-- Generated by sdk/js/scripts/generate-agent-docs.ts from developer-contract/openapi.json. Regenerated on every build. -->
+
+# `g8.api.skills`: Skills
+
+12 operations (5 read, 5 write, 1 destructive, 1 external).
+
+12 of these also have a hand-written method (`g8.skills`), marked **★** below. Prefer the hand-written method when one exists: it unwraps the `data` envelope and takes friendlier arguments. See [../sdk-clients.md](../sdk-clients.md).
+
+Every example below assumes this setup (server-side, API key):
+
+```ts
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+```
+
+Example values are placeholders that match each field's type. Only required fields are shown. Every example is type-checked against the SDK in CI.
+
+Exact TypeScript types for every operation on this page, and every schema they use: [skills.d.ts](skills.d.ts).
+
+## Operations
+
+| Call | HTTP | Tier | Scope | Summary |
+|---|---|---|---|---|
+| [`createFromNode`](#op-createfromnode) ★ | `POST /api/v1/skills/from-node` | write | `workflows:write` | Lift a workflow action node into a standalone skill |
+| [`createFromTemplate`](#op-createfromtemplate) ★ | `POST /api/v1/skills/from-template` | write | `workflows:write` | Create a skill from a template |
+| [`createSkill`](#op-createskill) ★ | `POST /api/v1/skills` | write | `workflows:write` | Create a skill (LLM or API runtime) |
+| [`deleteSkill`](#op-deleteskill) ★ | `DELETE /api/v1/skills/{action_id}` | destructive | `workflows:delete` | Delete a skill |
+| [`executeSkill`](#op-executeskill) ★ | `POST /api/v1/skills/{action_id}/execute` | external | `workflows:run` | Execute a skill once |
+| [`extractVariables`](#op-extractvariables) ★ | `GET /api/v1/skills/{action_id}/variables` | read | `workflows:read` | Extract {variable} placeholders from a skill's templates |
+| [`getSkill`](#op-getskill) ★ | `GET /api/v1/skills/{action_id}` | read | `workflows:read` | Get a skill's full configuration |
+| [`listModels`](#op-listmodels) ★ | `GET /api/v1/skills/models` | read | `workflows:read` | List supported LLM model identifiers |
+| [`listSkills`](#op-listskills) ★ | `GET /api/v1/skills` | read | `workflows:read` | List skills (LLM + API) for the caller's org |
+| [`listTemplates`](#op-listtemplates) ★ | `GET /api/v1/skills/templates` | read | `workflows:read` | List skill templates |
+| [`updateSkill`](#op-updateskill) ★ | `PUT /api/v1/skills/{action_id}` | write | `workflows:write` | Update a skill |
+| [`validateTemplate`](#op-validatetemplate) ★ | `POST /api/v1/skills/validate` | write | `workflows:write` | Validate a skill template (extract + warn on common mistakes) |
+
+---
+
+<a id="op-createfromnode"></a>
+
+### `g8.api.skills.createFromNode(input)`
+
+**Lift a workflow action node into a standalone skill**
+
+- HTTP: `POST /api/v1/skills/from-node`
+- operationId: `create_from_node_skills_from_node_post` (also callable as `g8.api.call("create_from_node_skills_from_node_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `workflows:write`
+- ★ Hand-written: [`g8.skills.createFromNode()`](../sdk-clients.md#g8-skills-createfromnode)
+
+Two-step lift (per PRD lock):
+  1) Fetch the workflow + locate the named node.
+  2) Resolve the referenced action_id, fetch its full config, then
+     POST to the SAME ``/api/v1/actions/create`` endpoint with a
+     derived name. The new action_id is returned.
+
+This is the route ``g8_skill_create_from_node`` MCP tool calls. It
+guarantees lift skills are byte-identical to authored skills.
+
+Does NOT modify the workflow — the lift is a copy, not a move. If
+the caller wants the workflow node to reference the new skill, they
+update the workflow themselves with ``g8_workflow_update_node``.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `Record<string, unknown>` | yes | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.createFromNode({ body: {} });
+```
+
+---
+
+<a id="op-createfromtemplate"></a>
+
+### `g8.api.skills.createFromTemplate(input)`
+
+**Create a skill from a template**
+
+- HTTP: `POST /api/v1/skills/from-template`
+- operationId: `create_from_template_skills_from_template_post` (also callable as `g8.api.call("create_from_template_skills_from_template_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `workflows:write`
+- ★ Hand-written: [`g8.skills.createFromTemplate()`](../sdk-clients.md#g8-skills-createfromtemplate)
+
+Instantiate a skill from a template. Forwards to voice's
+``POST /from-template/{template_id}`` with the caller's org_id pinned.
+
+Post-creation we re-fetch the new action and 404 if the resulting
+runtime_type is not a skill — guards against templates of workflow
+or script runtime sneaking into the skill surface.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `Record<string, unknown>` | yes | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.createFromTemplate({ body: {} });
+```
+
+---
+
+<a id="op-createskill"></a>
+
+### `g8.api.skills.createSkill(input)`
+
+**Create a skill (LLM or API runtime)**
+
+- HTTP: `POST /api/v1/skills`
+- operationId: `create_skill_skills_post` (also callable as `g8.api.call("create_skill_skills_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `workflows:write`
+- ★ Hand-written: [`g8.skills.createAPI()`](../sdk-clients.md#g8-skills-createapi), [`g8.skills.createLLM()`](../sdk-clients.md#g8-skills-createllm)
+
+Create a new skill. Pins ``org_id`` server-side and rejects any
+runtime_type other than ``llm`` or ``api``.
+
+Body must include ``name``, ``runtime_type`` (``llm`` or ``api``),
+and the matching ``llm_config`` or ``api_config`` block.
+
+This is the SAME endpoint that ``g8_skill_create_from_node`` (lift)
+routes through, so lifted skills are byte-identical to authored ones.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `Record<string, unknown>` | yes | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.createSkill({ body: {} });
+```
+
+---
+
+<a id="op-deleteskill"></a>
+
+### `g8.api.skills.deleteSkill(input)`
+
+**Delete a skill**
+
+- HTTP: `DELETE /api/v1/skills/{action_id}`
+- operationId: `delete_skill_skills__action_id__delete` (also callable as `g8.api.call("delete_skill_skills__action_id__delete", input)`)
+- Tier: `destructive`: deletes or archives data; confirm with a human before calling
+- API-key scope: `workflows:delete`
+- ★ Hand-written: [`g8.skills.delete()`](../sdk-clients.md#g8-skills-delete)
+
+Delete a skill. Pre-flight GET enforces the target is a skill
+before forwarding the DELETE.
+
+NOTE: this is a hard delete at the voice layer. Per the PRD lock,
+the skills surface does NOT do MCP-only soft-delete reference checks
+here — that logic lives in the MCP tool layer (where we can read
+workflow node references and refuse the delete).
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.action_id` | `string` | yes | Skill action_id. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+// destructive: deletes or archives data; confirm with a human before calling.
+const result = await g8.api.skills.deleteSkill({ path: { action_id: "id" } });
+```
+
+---
+
+<a id="op-executeskill"></a>
+
+### `g8.api.skills.executeSkill(input)`
+
+**Execute a skill once**
+
+- HTTP: `POST /api/v1/skills/{action_id}/execute`
+- operationId: `execute_skill_skills__action_id__execute_post` (also callable as `g8.api.call("execute_skill_skills__action_id__execute_post", input)`)
+- Tier: `external`: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first
+- API-key scope: `workflows:run`
+- ★ Hand-written: [`g8.skills.execute()`](../sdk-clients.md#g8-skills-execute)
+
+Run a skill once and return the execution result.
+
+Pre-flight GET enforces the action is a skill (not a workflow) so
+the skill execute surface stays sealed. ``org_id`` is pinned;
+``triggered_by`` defaults to the caller's user id.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.action_id` | `string` | yes | Skill action_id. |
+| `body` | `Record<string, unknown>` | no | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+// external: reaches real people (sends email/SMS, places a call, launches a send); the SDK never blindly retries it; confirm with a human first.
+const result = await g8.api.skills.executeSkill({ path: { action_id: "id" } });
+```
+
+---
+
+<a id="op-extractvariables"></a>
+
+### `g8.api.skills.extractVariables(input)`
+
+**Extract {variable} placeholders from a skill's templates**
+
+- HTTP: `GET /api/v1/skills/{action_id}/variables`
+- operationId: `extract_variables_skills__action_id__variables_get` (also callable as `g8.api.call("extract_variables_skills__action_id__variables_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `workflows:read`
+- ★ Hand-written: [`g8.skills.getVariables()`](../sdk-clients.md#g8-skills-getvariables)
+
+Return the deduplicated, first-seen-order list of ``{variable}``
+placeholders extracted from the skill's templates.
+
+For LLM skills we scan ``llm_config.prompt_template``.
+For API skills we scan ``api_config.endpoint``, ``api_config.body_template``,
+every header value, and every query param value.
+
+Single-brace regex only — ``{{double_brace}}`` patterns are ignored
+to avoid pulling Jinja control structures out as variables.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.action_id` | `string` | yes | Skill action_id. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.extractVariables({ path: { action_id: "id" } });
+```
+
+---
+
+<a id="op-getskill"></a>
+
+### `g8.api.skills.getSkill(input)`
+
+**Get a skill's full configuration**
+
+- HTTP: `GET /api/v1/skills/{action_id}`
+- operationId: `get_skill_skills__action_id__get` (also callable as `g8.api.call("get_skill_skills__action_id__get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `workflows:read`
+- ★ Hand-written: [`g8.skills.get()`](../sdk-clients.md#g8-skills-get)
+
+Return the full skill record (llm_config / api_config + metadata).
+
+Returns 404 for workflow / script rows even if voice has them —
+the skill surface is sealed.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.action_id` | `string` | yes | Skill action_id. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.getSkill({ path: { action_id: "id" } });
+```
+
+---
+
+<a id="op-listmodels"></a>
+
+### `g8.api.skills.listModels(input?)`
+
+**List supported LLM model identifiers**
+
+- HTTP: `GET /api/v1/skills/models`
+- operationId: `list_models_skills_models_get` (also callable as `g8.api.call("list_models_skills_models_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `workflows:read`
+- ★ Hand-written: [`g8.skills.listModels()`](../sdk-clients.md#g8-skills-listmodels)
+
+Return the static catalog of LLM model ids the create/update
+endpoints accept. Voice ultimately decides which models route to
+which provider — this catalog is a hint for MCP clients filling in
+the ``model`` field of ``g8_skill_create_llm``.
+
+**Input**: none.
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.listModels();
+```
+
+---
+
+<a id="op-listskills"></a>
+
+### `g8.api.skills.listSkills(input?)`
+
+**List skills (LLM + API) for the caller's org**
+
+- HTTP: `GET /api/v1/skills`
+- operationId: `list_skills_skills_get` (also callable as `g8.api.call("list_skills_skills_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `workflows:read`
+- ★ Hand-written: [`g8.skills.list()`](../sdk-clients.md#g8-skills-list)
+
+List skills owned by the org. When ``runtime_type`` is omitted we
+make two voice calls (one for llm, one for api) and merge the results,
+so the public surface always returns just the two allowed runtimes
+and never leaks workflows/scripts even if voice's filter logic drifts.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.runtime_type` | `string \| null` | no | Filter to a single runtime (llm or api). Omit to see both. |
+| `query.enabled` | `boolean \| null` | no | Filter by enabled flag. |
+| `query.category` | `string \| null` | no | Filter by category. |
+| `query.object_type` | `string \| null` | no | Filter by entity type the skill targets. |
+| `query.include_system` | `boolean` | no | Include shared system-default skills alongside org-owned ones. default `true` |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.listSkills();
+```
+
+---
+
+<a id="op-listtemplates"></a>
+
+### `g8.api.skills.listTemplates(input?)`
+
+**List skill templates**
+
+- HTTP: `GET /api/v1/skills/templates`
+- operationId: `list_templates_skills_templates_get` (also callable as `g8.api.call("list_templates_skills_templates_get", input)`)
+- Tier: `read`: reads data; safe to call and to retry
+- API-key scope: `workflows:read`
+- ★ Hand-written: [`g8.skills.listTemplates()`](../sdk-clients.md#g8-skills-listtemplates)
+
+List skill templates available in the caller's org plus shared
+system templates. Workflow templates are filtered out client-side.
+
+Voice's ``GET /templates/{org_id}/list`` returns all template rows
+(including workflow templates). We filter post-fetch so the public
+surface stays sealed to skills only.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `query.category` | `string \| null` | no | Filter by category. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.listTemplates();
+```
+
+---
+
+<a id="op-updateskill"></a>
+
+### `g8.api.skills.updateSkill(input)`
+
+**Update a skill**
+
+- HTTP: `PUT /api/v1/skills/{action_id}`
+- operationId: `update_skill_skills__action_id__put` (also callable as `g8.api.call("update_skill_skills__action_id__put", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `workflows:write`
+- ★ Hand-written: [`g8.skills.updateAPI()`](../sdk-clients.md#g8-skills-updateapi), [`g8.skills.updateLLM()`](../sdk-clients.md#g8-skills-updatellm)
+
+Update an existing skill. Pre-flight GET enforces the action is
+actually a skill (not a workflow/script) before forwarding the PUT.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `path.action_id` | `string` | yes | Skill action_id. |
+| `body` | `Record<string, unknown>` | yes | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.updateSkill({ path: { action_id: "id" }, body: {} });
+```
+
+---
+
+<a id="op-validatetemplate"></a>
+
+### `g8.api.skills.validateTemplate(input)`
+
+**Validate a skill template (extract + warn on common mistakes)**
+
+- HTTP: `POST /api/v1/skills/validate`
+- operationId: `validate_template_skills_validate_post` (also callable as `g8.api.call("validate_template_skills_validate_post", input)`)
+- Tier: `write`: creates or changes records; the SDK sends an Idempotency-Key and retries transient failures
+- API-key scope: `workflows:write`
+- ★ Hand-written: [`g8.skills.validate()`](../sdk-clients.md#g8-skills-validate)
+
+Dry-run template validator. Returns extracted variables plus
+warnings about common mistakes (double-brace usage, unmatched braces).
+
+Per the PRD lock (Q3): warn-only. We never block creation on warnings
+here — the user is the source of truth and a double-brace pattern is
+valid Jinja that voice's runtime may handle differently from skills.
+
+Accepts two shapes:
+  1) ``{"template": "Hello {name}"}`` — one string in, vars out.
+  2) ``{"runtime_type": "llm", "llm_config": {...}}`` — full skill
+     shape, scans every template field the matching runtime would use.
+
+**Input**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `body` | `Record<string, unknown>` | yes | Request body; fields below. |
+
+**Returns** `Record<string, unknown>`.
+
+**Example**
+
+```ts
+const result = await g8.api.skills.validateTemplate({ body: {} });
+```