---
title: "ಡೆವಲಪರ್ ಮಾರ್ಗದರ್ಶಿ"
description: "Quire ನ REST API, OAuth, webhooks, MCP ಸರ್ವರ್ ಮತ್ತು ವಿಸ್ತರಣೆಗಳು."
image: "https://docs.quirelms.com/og.png"
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.quirelms.com/kn/llms.txt
> Use this file to discover all available pages before exploring further.

# ಡೆವಲಪರ್ ಮಾರ್ಗದರ್ಶಿ

<span id="developer-guide"></span>

ನಿಮ್ಮ ಸಂಸ್ಥೆಯ API ವಿಳಾಸ ಮತ್ತು ಸ್ಕೋಪ್ ಮಾಡಿದ ಪರಿಚಯಪತ್ರವನ್ನು ಬಳಸಿ. ಒಂದು ಓದುವ
ವಿನಂತಿಯೊಂದಿಗೆ ಆರಂಭಿಸಿ, ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ, ಮತ್ತು ರಹಸ್ಯಗಳನ್ನು ಮೂಲ ನಿಯಂತ್ರಣ ಮತ್ತು
ದಸ್ತಾವೇಜು ಉದಾಹರಣೆಗಳ ಹೊರಗೆ ಇಡಿ.

Quire ಒಂದೇ ಸಾರ್ವಜನಿಕ API ಹೊಂದಿದೆ: HTTPS ಮೇಲಿನ REST, OpenAPI 3.1
ಡಾಕ್ಯುಮೆಂಟ್‌ನಿಂದ ವಿವರಿಸಲ್ಪಟ್ಟಿದೆ, ಈವೆಂಟ್‌ಗಳಿಗೆ ಸಹಿ ಮಾಡಿದ webhooks ಮತ್ತು AI
ಸಹಾಯಕರಿಗೆ ಒಂದು MCP ಸರ್ವರ್ ಸಹಿತ. [API ಉಲ್ಲೇಖ](https://docs.quirelms.com/api/) ಪ್ರತಿ endpoint ಮತ್ತು
ಈವೆಂಟ್ ಅನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.

## ವಿಳಾಸಗಳು <!--quire:addresses-->

ಪ್ರತಿ ಸಂಸ್ಥೆಗೂ ತನ್ನದೇ ವಿಳಾಸವಿರುತ್ತದೆ, ಮತ್ತು API ಅದರ ಅಡಿಯಲ್ಲಿರುತ್ತದೆ:

```
https://acme.quirelms.com/api/v1/courses
```

ಪರಿಚಯಪತ್ರವು ಸಂಸ್ಥೆಯನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಒಂದು ಸಂಸ್ಥೆಗಾದ ಕೀ ಅನ್ನು ಇನ್ನೊಂದರ ವಿಳಾಸದಲ್ಲಿ
ಬಳಸಿದರೆ ಅದನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ.

OpenAPI ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಯಾವುದೇ ಸಂಸ್ಥೆಯ ವಿಳಾಸದಲ್ಲಿ `/api/v1/openapi.json` ನಲ್ಲಿ
ಒದಗಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಕ್ಲೈಂಟ್ ಜನರೇಟರ್‌ಗಳು ಯಾವಾಗಲೂ ನೀವು ಕರೆ ಮಾಡುತ್ತಿರುವ
ಆವೃತ್ತಿಯನ್ನೇ ನೋಡುತ್ತವೆ.

## ದೃಢೀಕರಣ <!--quire:authentication-->

**API ಕೀಗಳು** ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಸರ್ವರ್-ಟು-ಸರ್ವರ್ ಏಕೀಕರಣಗಳಿಗೆ. ಒಬ್ಬ ನಿರ್ವಾಹಕರು
`/admin/integrations/api-keys` ನಲ್ಲಿ ಒಂದನ್ನು ರಚಿಸುತ್ತಾರೆ, ಅದರ ಸ್ಕೋಪ್‌ಗಳನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತಾರೆ,
ಮತ್ತು ಅದನ್ನು ಒಮ್ಮೆ ನೋಡುತ್ತಾರೆ. ಅದನ್ನು bearer ಟೋಕನ್ ಆಗಿ ಕಳುಹಿಸಿ:

```
curl -H "Authorization: Bearer qk_live_..." https://acme.quirelms.com/api/v1/users?limit=50
```

ಕೀಗಳು `qk_live_` ಅಥವಾ `qk_test_` ನಿಂದ ಆರಂಭವಾಗುತ್ತವೆ. ಪ್ರತಿ ಏಕೀಕರಣಕ್ಕೂ ಅದರ ಸ್ವಂತ ಕೀ
ನೀಡಿ.

**OAuth 2.1** ಸೈನ್ ಇನ್ ಆದ ವ್ಯಕ್ತಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ. 
`/admin/integrations/oauth-clients` ನಲ್ಲಿ ಒಂದು ಕ್ಲೈಂಟ್ ನೋಂದಾಯಿಸಿ, ನಂತರ PKCE ಸಹಿತ
ಅಧಿಕಾರ ಕೋಡ್ ಹರಿವನ್ನು ಬಳಸಿ (`/oauth/authorize`, `/oauth/token`), ಅಥವಾ ಯಂತ್ರ
ಕ್ಲೈಂಟ್‌ಗಾಗಿ ಕ್ಲೈಂಟ್ ಪರಿಚಯಪತ್ರಗಳನ್ನು ಬಳಸಿ. ಡಿಸ್ಕವರಿ `/.well-known/oauth-authorization-server` ನಲ್ಲಿದೆ.
ಸ್ಕೋಪ್ ಟೋಕನ್ ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ; ಅದು ಆ ವ್ಯಕ್ತಿ ಮಾಡಬಹುದಾದ್ದಕ್ಕಿಂತ
ಹೆಚ್ಚು ಮಾಡಲು ಎಂದಿಗೂ ಅವಕಾಶ ನೀಡುವುದಿಲ್ಲ.

ಸ್ಕೋಪ್‌ಗಳು `resource:read`, `resource:write` ಮತ್ತು `resource:delete`, ಉದಾಹರಣೆಗೆ
`courses:read` ಅಥವಾ `enrolments:write`. ನಾಲ್ಕು ವಿಶೇಷಾಧಿಕಾರ ಹೊಂದಿವೆ ಮತ್ತು ಒಪ್ಪಿಗೆ
ಪರದೆಯಲ್ಲಿ ಎಚ್ಚರಿಕೆಯೊಂದಿಗೆ ತೋರಿಸಲ್ಪಡುತ್ತವೆ: `audit:read`, `roles:write`,
`tenants:write` ಮತ್ತು `users:delete`.

<figure class="quire-shot" lang="en" dir="ltr"><img src="/screenshots/admin-api-keys.webp" alt="The API keys page with one key, the person it acts as, its scopes and its status, and a form to create another." width="944" height="700" loading="lazy" decoding="async"><figcaption>API keys list who each key acts as and what it may reach.</figcaption></figure>

## ವಿನಂತಿಗಳು <!--quire:requests-->

- **ಪುಟರಚನೆ**: ಪ್ರತಿ ಪಟ್ಟಿಯೂ cursor ಪುಟರಚನೆ ಹೊಂದಿದೆ. `limit` ಕಳುಹಿಸಿ, ನಂತರ
  `next_cursor` ಅನ್ನು `page` ನಲ್ಲಿಂದ `cursor` ಆಗಿ, `has_more` ಸತ್ಯವಾಗಿರುವವರೆಗೆ
  ಕಳುಹಿಸಿ (ಕೆಳಗಿನ ಉದಾಹರಣೆ). offset ಇಲ್ಲ.
- **ಬದಲಾವಣೆಗಳು ನಂತರ**: `updated_since` ಒಂದು ಸಮಯದ ನಂತರ ಏನು ಬದಲಾಗಿದೆ ಎಂದು
  ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅದನ್ನು `include_deleted=true` ಜೊತೆಗೆ ಜೋಡಿಸಿ, ಅಥವಾ ಏನು
  ತೆಗೆದುಹಾಕಲಾಗಿತ್ತು ಎಂದು ತಿಳಿದುಕೊಳ್ಳಲು `/<resource>/deletions` ಓದಿ.
- **ಬಾಹ್ಯ ಗುರುತುಗಳು**: ಬಹುತೇಕ ಸಂಪನ್ಮೂಲಗಳು ನಿಮ್ಮ ಸ್ವಂತ `external_id` ಸ್ವೀಕರಿಸುತ್ತವೆ,
  ಮತ್ತು `/<resource>/ext:{external_id}` ಅದರ ಮೂಲಕ ಓದುತ್ತದೆ ಅಥವಾ upsert ಮಾಡುತ್ತದೆ,
  ಆದ್ದರಿಂದ ಒಂದು sync ಗೆ Quire ನ ಗುರುತುಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಅಗತ್ಯವೇ ಇರುವುದಿಲ್ಲ.
- **ಇಡೆಂಪೊಟೆನ್ಸಿ**: `Idempotency-Key` ಹೆಡರ್ ಅನ್ನು `POST`, `PATCH` ಮತ್ತು `DELETE` ಮೇಲೆ
  ಕಳುಹಿಸಿ. ಅದೇ ಕೀಯೊಂದಿಗೆ ಮರುಪ್ರಯತ್ನವು ಕೆಲಸವನ್ನು ಎರಡು ಬಾರಿ ಮಾಡದೆ ಮೊದಲ
  ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಬಲ್ಕ್ endpoints ಗೆ ಅದು ಕಡ್ಡಾಯ.
- **ಆವೃತ್ತಿಗಳು**: ಮುಖ್ಯ ಆವೃತ್ತಿಯು ಮಾರ್ಗದಲ್ಲಿದೆ (`/v1`). ಅದರೊಳಗೆ, ಪ್ರತಿ ಒಡೆಯುವ
  ಬದಲಾವಣೆಯೂ ದಿನಾಂಕಿತ ತಿದ್ದುಪಡಿಯಾಗಿದೆ, `Quire-Version` ಹೆಡರ್‌ನೊಂದಿಗೆ ಆಯ್ಕೆ
  ಮಾಡಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ `Quire-Version: 2026-09-20`. ಹೆಡರ್ ಇಲ್ಲದಿದ್ದರೆ
  ನಿಮ್ಮ ಪರಿಚಯಪತ್ರ ನೀಡಿದಾಗ ಪ್ರಚಲಿತ ತಿದ್ದುಪಡಿಯನ್ನು ಪಡೆಯುತ್ತೀರಿ.

ಒಂದು ಪಟ್ಟಿಯ ಒಂದು ಪುಟ:

```
{"data": [...], "page": {"next_cursor": "eyJ2Ijox...", "has_more": true, "limit": 100}}
```

## ದೋಷಗಳು <!--quire:errors-->

ಪ್ರತಿ ದೋಷವೂ ಒಂದು RFC 9457 ಸಮಸ್ಯಾ ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿದೆ:

```
{"type": "https://quire.com/errors/enrolment.seat_limit_reached",
 "title": "Seat limit reached", "status": 409,
 "code": "enrolment.seat_limit_reached", "category": "conflict",
 "detail": "The course has no seats left, so this enrolment was not created. ...",
 "request_id": "01JB7XQK4Z..."}
```

ಸ್ಥಿರವಾಗಿರುವ `code` ಮೂಲಕ ಶಾಖೆ ಮಾಡಿ; `detail` ಜನರಿಗಾಗಿ ಬರೆಯಲ್ಪಟ್ಟಿದೆ, ಅವರಿಗೆ
ತೋರಿಸಲು ಸುರಕ್ಷಿತ, ಮತ್ತು ಬದಲಾಗಬಹುದು. ಒಂದು ಕೋಡ್ ನಿಮಗೆ ಗೊತ್ತಿಲ್ಲದಿದ್ದರೆ,
`category` ಮೂಲಕ ವಿಂಗಡಿಸಿ:

| ವರ್ಗ | ಸ್ಥಿತಿ | ಮರುಪ್ರಯತ್ನ |
| --- | --- | --- |
| `validation` | 422, `errors` ನಲ್ಲಿ ಕ್ಷೇತ್ರ ವಿವರದೊಂದಿಗೆ | ಇಲ್ಲ |
| `authentication` | 401 | ಇಲ್ಲ |
| `authorization` | 403 | ಇಲ್ಲ |
| `not_found` | 404 | ಇಲ್ಲ |
| `conflict` | 409 | ಕೆಲವೊಮ್ಮೆ |
| `precondition` | 412 | ಇಲ್ಲ |
| `quota` | ಯೋಜನೆಗೆ 402, ಗಾತ್ರಕ್ಕೆ 413 | ಇಲ್ಲ |
| `rate_limit` | 429, `Retry-After` ಸಹಿತ | ಹೌದು |
| `upstream` | 502 ಅಥವಾ 504 | ಹೌದು |
| `internal` | 500 | ಹೌದು |

ನೀವು ಬೆಂಬಲವನ್ನು ಸಂಪರ್ಕಿಸಿದಾಗ `request_id` ಉಲ್ಲೇಖಿಸಿ.

## Webhooks <!--quire:webhooks-->

`/admin/webhooks` ನಲ್ಲಿ ಚಂದಾದಾರರಾಗಿ, ಅಥವಾ API ಮೂಲಕ
`/webhook_subscriptions` ನಲ್ಲಿ. ಈವೆಂಟ್‌ಗಳನ್ನು ಹೆಸರಿನ ಮೂಲಕ (`enrolment.created`),
ವಲಯದ ಮೂಲಕ (`enrolment.*`) ಅಥವಾ ಎಲ್ಲವನ್ನೂ (`*`) ಆಯ್ಕೆಮಾಡಿ. Quire ಮೊದಲು ಒಂದು
`webhook.ping` ಕಳುಹಿಸುತ್ತದೆ; ನಿಮ್ಮ endpoint ಅದಕ್ಕೆ ಉತ್ತರಿಸಿದಾಗ ಚಂದಾದಾರಿಕೆ
ಆರಂಭವಾಗುತ್ತದೆ.

ಡೆಲಿವರಿಗಳು Standard Webhooks ವಿಶೇಷಣವನ್ನು ಅನುಸರಿಸುತ್ತವೆ:

```
POST /hooks/quire
webhook-id: 01JB7XQK4Z8FQ2M3N4P5R6S7T8
webhook-timestamp: 1790000000
webhook-signature: v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=
```

ಒಂದು ಡೆಲಿವರಿ ಪರಿಶೀಲಿಸಲು:

1. ಯಾವುದೇ JSON ಪಾರ್ಸಿಂಗ್ ಮೊದಲು, ಸ್ವೀಕರಿಸಲಾದ ನಿಖರ ಬೈಟ್‌ಗಳಿಂದ
   `{webhook-id}.{webhook-timestamp}.{raw body}` ಸ್ಟ್ರಿಂಗ್ ರಚಿಸಿ.
2. ನಿಮ್ಮ ಚಂದಾದಾರಿಕೆ ರಹಸ್ಯದೊಂದಿಗೆ ಅದರ ಮೇಲೆ HMAC-SHA256 ಲೆಕ್ಕಹಾಕಿ, ಮತ್ತು ಅದನ್ನು base64 ಮಾಡಿ.
3. ಪ್ರತಿ `v1,` ಮೌಲ್ಯವನ್ನು `webhook-signature` ನಲ್ಲಿ ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಹೋಲಿಸಿ.
   ರಹಸ್ಯ ರೊಟೇಶನ್‌ನ ಸಮಯದಲ್ಲಿ ಎರಡು ಇರಬಹುದು; ಯಾವುದಾದರೂ ಹೊಂದಿಕೊಂಡರೆ ಅದು ಮಾನ್ಯ.
4. ನಿಮ್ಮ ಗಡಿಯಾರದಿಂದ ಐದು ನಿಮಿಷಕ್ಕಿಂತ ಹೆಚ್ಚು ದೂರವಿರುವ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು
   ತಿರಸ್ಕರಿಸಿ.

```
import { createHmac, timingSafeEqual } from 'node:crypto';

function verify(secret, id, timestamp, rawBody, header) {
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false;
  const expected = createHmac('sha256', Buffer.from(secret.replace(/^whsec_/, ''), 'base64'))
    .update(`${id}.${timestamp}.${rawBody}`).digest();
  return header.split(' ').some((part) => {
    const [version, value] = part.split(',');
    const given = Buffer.from(value ?? '', 'base64');
    return version === 'v1' && given.length === expected.length && timingSafeEqual(given, expected);
  });
}
```

`webhook-id` ಮೂಲಕ ನಕಲುಗಳನ್ನು ತಡೆಯಿರಿ: ಒಂದು ಡೆಲಿವರಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ
ಬರಬಹುದು. ದೇಹವು ಗುರುತುಗಳು ಮತ್ತು ಸಣ್ಣ ಸಾರಾಂಶವನ್ನು ಹೊತ್ತೊಯ್ಯುತ್ತದೆ; ಅದರ ಪ್ರಸ್ತುತ
ಸ್ಥಿತಿಗಾಗಿ ಸಂಪನ್ಮೂಲವನ್ನು ಪಡೆಯಿರಿ. ವಿಫಲ ಡೆಲಿವರಿಗಳನ್ನು 72 ಗಂಟೆಗಳವರೆಗೆ ಹಿಂತಿರುಗಣಿಸಿ
ಮರುಪ್ರಯತ್ನಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಡೆಲಿವರಿ ಲಾಗ್‌ನಿಂದ ಮರುಪ್ರಸಾರ ಮಾಡಬಹುದು.

## MCP <!--quire:mcp-->

Quire ನ MCP ಸರ್ವರ್ ಸಂಸ್ಥೆಯ ವಿಳಾಸದಲ್ಲಿ `/mcp` ನಲ್ಲಿದೆ, streamable HTTP ಮೂಲಕ.
ಒಂದು MCP ಕ್ಲೈಂಟ್ `/.well-known/oauth-protected-resource` ನಿಂದ OAuth ಸರ್ವರ್ ಅನ್ನು
ಕಂಡುಹಿಡಿಯುತ್ತದೆ, ಮತ್ತು ಯಾವುದೇ OAuth ಕ್ಲೈಂಟ್‌ನಂತೆ ವ್ಯಕ್ತಿಯು ಸೈನ್ ಇನ್ ಮಾಡಿ ಒಪ್ಪಿಗೆ
ನೀಡುತ್ತಾರೆ. ಸಾಧನಗಳು ಆ ವ್ಯಕ್ತಿಯಾಗಿ, ಅವರ ಅನುಮತಿಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಮತ್ತು
ವಿನಾಶಕಾರಿ ಸಾಧನಗಳು ದೃಢೀಕರಣವನ್ನು ಕೇಳುತ್ತವೆ. ನಿರ್ವಾಹಕರು `/admin/integrations/mcp` ನಲ್ಲಿ
ಯಾವ ಸಾಧನಗಳು ಲಭ್ಯವಿವೆ ಎಂದು ಆಯ್ಕೆಮಾಡುತ್ತಾರೆ.

<figure class="quire-shot" lang="en" dir="ltr"><img src="/screenshots/admin-mcp.webp" alt="The AI assistants page with the server address to give an assistant and a table of the tools it can use." width="944" height="700" loading="lazy" decoding="async"><figcaption>AI assistants (MCP): the server address, and the tools an assistant may call.</figcaption></figure>

## ಯೋಜನೆಗಳು ಮತ್ತು API <!--quire:plans-and-the-api-->

API ಕೀಗಳು, OAuth ಕ್ಲೈಂಟ್‌ಗಳು, webhooks ಮತ್ತು MCP ಸರ್ವರ್ ಯೋಜನೆಯ API ಹಕ್ಕಿಗೆ
ಸೇರಿವೆ, ಮತ್ತು ಪ್ರತಿ ಸಾಮಾನ್ಯ ಯೋಜನೆಯೂ ಅದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಅದಿಲ್ಲದ ಯೋಜನೆಯಲ್ಲಿ,
ಕೀ, ಕ್ಲೈಂಟ್ ಅಥವಾ ಚಂದಾದಾರಿಕೆ ರಚಿಸುವಿಕೆಯನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ, REST ಬರೆಯುವಿಕೆ ಮತ್ತು
MCP ಸಂಪರ್ಕಗಳನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು REST ಓದುವಿಕೆಗಳು ಮುಂದುವರಿಯುತ್ತವೆ, ಆಗ
ಡೇಟಾ ರಫ್ತು ಮಾಡಬಹುದಾಗಿ ಉಳಿಯುತ್ತದೆ. ನಿರಾಕರಣೆಯು `commerce.plan_entitlement` ಕೋಡ್ ಹೊಂದಿರುವ,
`precondition` ವರ್ಗದ ಸಮಸ್ಯಾ ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿದೆ.

## ವಿಸ್ತರಣೆಗಳು <!--quire:extensions-->

Quire ನ ಸ್ವಂತ ಚಟುವಟಿಕೆ ಪ್ರಕಾರಗಳು, ಬ್ಲಾಕ್‌ಗಳು, ನಮೂದಿಸುವಿಕೆ ವಿಧಾನಗಳು, ಸೈನ್-ಇನ್
ವಿಧಾನಗಳು, ಪ್ರಶ್ನಾ ಪ್ರಕಾರಗಳು, ವರದಿಗಳು, ಥೀಮ್‌ಗಳು ಮತ್ತು ಏಕೀಕರಣಗಳನ್ನು ಸ್ವ-ಹೋಸ್ಟ್
ಸ್ಥಾಪನೆಯು ಸೇರಿಸಬಹುದಾದ ಅದೇ ವಿಸ್ತರಣಾ ರಿಜಿಸ್ಟ್ರಿಯ ಮೂಲಕ ಘೋಷಿಸಲಾಗುತ್ತದೆ. ವಿಸ್ತರಣೆಗಳು
ಸಂಕಲನಗೊಂಡಿವೆ: ರನ್‌ಟೈಮ್ ಪ್ಲಗಿನ್ ಲೋಡರ್ ಇಲ್ಲ, ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಿದ ಸಂಸ್ಥೆಯು ಒಂದನ್ನು
ಸೇರಿಸಲಾಗದು. ನಿರ್ವಾಹಕರು ತಮ್ಮ ಸಂಸ್ಥೆಗಾಗಿ ಪ್ರತಿ ವಿಸ್ತರಣೆಯನ್ನು `/admin/extensions` ನಲ್ಲಿ
ಆನ್ ಅಥವಾ ಆಫ್ ಮಾಡುತ್ತಾರೆ ([ನಿರ್ವಾಹಕ ಮಾರ್ಗದರ್ಶಿ](/kn/admin/extensions/) ನೋಡಿ).

ಒಂದನ್ನು ಬರೆಯಲು, `packages/integration/extensions/src/sample.ts` ನಲ್ಲಿನ ಮಾದರಿ
ಬ್ಲಾಕ್ ಮತ್ತು ಥೀಮ್‌ನಿಂದ ಆರಂಭಿಸಿ. ವಿಸ್ತರಣಾ ಬಿಂದುವನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು `points.ts` ನಲ್ಲಿ
ಅದರ ಒಪ್ಪಂದವನ್ನು ಓದಿ, ನಂತರ ಒಂದು id, ಒಂದು ಆವೃತ್ತಿ, ಒಂದು ಪರವಾನಗಿ, ಅದು ಒದಗಿಸುವುದು
ಮತ್ತು ಬೇಕಾದದ್ದು, ಮತ್ತು ಒಂದು ಸಂಸ್ಥೆಯು ಅದನ್ನು ಆಫ್ ಮಾಡಬಹುದೇ ಎಂಬುದರೊಂದಿಗೆ ವಿಸ್ತರಣೆಯನ್ನು
ಘೋಷಿಸಿ. ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ವರ್ಕರ್ ಸಂಯೋಜಿಸಲ್ಪಡುವ ಜಾಗದಲ್ಲಿ ಅದನ್ನು ನೋಂದಾಯಿಸಿ, ಆಗ
ಎರಡೂ ಒಪ್ಪುತ್ತವೆ. ರಿಜಿಸ್ಟ್ರಿಯು ಕಟ್ಟಡವಾದಾಗ ಮತ್ತು ನೀವು ಪ್ರತಿ ಬಾರಿ `register` ಕರೆ ಮಾಡಿದಾಗ
ಪ್ರತಿ ಬಿಂದುವಿನ ಸ್ವಂತ ನಿಯಮಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಪ್ರತಿ ಸಮಸ್ಯೆಯನ್ನೂ ಹೆಸರಿಸಿ ಅಮಾನ್ಯವಾಗುತ್ತಿದ್ದ
ಸೆಟ್ ಅನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ, ಮತ್ತು ಅಂತಹ ಸಮಸ್ಯೆ ಇದ್ದರೆ ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಬದಲಾಯಿಸದೆ ಬಿಡುತ್ತದೆ.
ವಿಸ್ತರಣೆಯ ಸ್ವಂತ ಪರೀಕ್ಷೆಗಳು ಅದಕ್ಕಾಗಿ `extensionContractProblems` ಖಾಲಿಯಾಗಿದೆ ಎಂದು ಮತ್ತು
ಅದನ್ನು ಆಫ್ ಮಾಡಿದಾಗ ಅದು ಪ್ರಭಾವಿಸುವುದು ಬದಲಾಗುತ್ತದೆ ಎಂದು ಸ್ಥಾಪಿಸಬೇಕು.

Source: https://docs.quirelms.com/kn/developer/index.mdx