feat: Add createOpenStatusClient factory for reusable auth configuration (#10)

Add a new `createOpenStatusClient(options)` factory function that allows
users to configure authentication once and reuse it across all API calls,
eliminating the need to pass headers on every request.

Changes:
- Add `OpenStatusClientOptions` interface with `apiKey` and `baseUrl` options
- Add `createAuthInterceptor` to automatically inject auth headers
- Add `createOpenStatusClient` factory function
- Update README with new recommended usage pattern
- Update all code examples to use the new client-based approach

Usage:
```typescript
const client = createOpenStatusClient({
apiKey: process.env.OPENSTATUS_API_KEY,
});

// No headers needed on each call
await client.monitor.v1.MonitorService.listMonitors({});
```

The default `openstatus` export is preserved for backwards compatibility.

README.md

···
 ### Deno
 
 ```typescript
-import { openstatus } from "jsr:@openstatus/sdk-node";
+import { createOpenStatusClient } from "jsr:@openstatus/sdk-node";
 ```
 
 ## Quick Start
 
 ```typescript
 import {
+  createOpenStatusClient,
   HTTPMethod,
   NumberComparator,
-  openstatus,
   Periodicity,
   Region,
 } from "@openstatus/sdk-node";
 
-const headers = {
-  "x-openstatus-key": process.env.OPENSTATUS_API_KEY,
-};
+// Create a client with your API key
+const client = createOpenStatusClient({
+  apiKey: process.env.OPENSTATUS_API_KEY,
+});
 
 // Create a monitor
-const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor(
-  {
-    monitor: {
-      name: "My API",
-      url: "https://api.example.com/health",
-      periodicity: Periodicity.PERIODICITY_1M,
-      method: HTTPMethod.HTTP_METHOD_GET,
-      regions: [Region.FLY_AMS, Region.FLY_IAD, Region.FLY_SYD],
-      active: true,
-      statusCodeAssertions: [
-        { comparator: NumberComparator.EQUAL, target: BigInt(200) },
-      ],
-    },
+const { monitor } = await client.monitor.v1.MonitorService.createHTTPMonitor({
+  monitor: {
+    name: "My API",
+    url: "https://api.example.com/health",
+    periodicity: Periodicity.PERIODICITY_1M,
+    method: HTTPMethod.HTTP_METHOD_GET,
+    regions: [Region.FLY_AMS, Region.FLY_IAD, Region.FLY_SYD],
+    active: true,
+    statusCodeAssertions: [
+      { comparator: NumberComparator.EQUAL, target: BigInt(200) },
+    ],
   },
-  { headers },
-);
+});
 
 console.log(`Monitor created: ${monitor?.id}`);
 
 // List all monitors
-const { httpMonitors, tcpMonitors, dnsMonitors, totalSize } =
-  await openstatus.monitor.v1.MonitorService.listMonitors({}, { headers });
+const { httpMonitors, tcpMonitors, dnsMonitors, totalSize } = await client
+  .monitor.v1.MonitorService.listMonitors({});
 
 console.log(`Found ${totalSize} monitors`);
 ```
···
 All API requests require an API key. Get yours from the
 [OpenStatus dashboard](https://www.openstatus.dev/app).
 
+### Recommended: Configure client once
+
 ```typescript
+import { createOpenStatusClient } from "@openstatus/sdk-node";
+
+const client = createOpenStatusClient({
+  apiKey: process.env.OPENSTATUS_API_KEY,
+});
+
+// No need to pass headers on each call
+await client.monitor.v1.MonitorService.listMonitors({});
+```
+
+### Alternative: Manual headers
+
+```typescript
+import { openstatus } from "@openstatus/sdk-node";
+
 const headers = {
   "x-openstatus-key": process.env.OPENSTATUS_API_KEY,
 };
 
-// Pass headers to any service method
+// Pass headers to each service method
 await openstatus.monitor.v1.MonitorService.listMonitors({}, { headers });
 ```
 
···
 
 ## SDK Reference
 
+> **Note:** All examples below assume you've created a client:
+>
+> ```typescript
+> const client = createOpenStatusClient({
+>   apiKey: process.env.OPENSTATUS_API_KEY,
+> });
+> ```
+
 ### Monitor Service
 
 Manage HTTP, TCP, and DNS monitors.
 
-#### `createHTTPMonitor(request, options)`
+#### `createHTTPMonitor(request)`
 
 Create an HTTP/HTTPS monitor.
 
 ```typescript
-import { HTTPMethod, Periodicity, Region } from "@openstatus/sdk-node";
+import {
+  createOpenStatusClient,
+  HTTPMethod,
+  Periodicity,
+  Region,
+} from "@openstatus/sdk-node";
 
-const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor(
-  {
-    monitor: {
-      name: "My Website",
-      url: "https://example.com",
-      periodicity: Periodicity.PERIODICITY_1M,
-      method: HTTPMethod.HTTP_METHOD_GET,
-      regions: [Region.FLY_AMS, Region.FLY_IAD, Region.FLY_SYD],
-      active: true,
-    },
+const { monitor } = await client.monitor.v1.MonitorService.createHTTPMonitor({
+  monitor: {
+    name: "My Website",
+    url: "https://example.com",
+    periodicity: Periodicity.PERIODICITY_1M,
+    method: HTTPMethod.HTTP_METHOD_GET,
+    regions: [Region.FLY_AMS, Region.FLY_IAD, Region.FLY_SYD],
+    active: true,
   },
-  { headers },
-);
+});
 ```
 
-#### `updateHTTPMonitor(request, options)`
+#### `updateHTTPMonitor(request)`
 
 Update an existing HTTP monitor.
 
 ```typescript
-const { monitor } = await openstatus.monitor.v1.MonitorService.updateHTTPMonitor(
-  {
-    id: "mon_123",
-    monitor: {
-      name: "Updated Name",
-      active: false,
-    },
+const { monitor } = await client.monitor.v1.MonitorService.updateHTTPMonitor({
+  id: "mon_123",
+  monitor: {
+    name: "Updated Name",
+    active: false,
   },
-  { headers },
-);
+});
 ```
 
-#### `createTCPMonitor(request, options)`
+#### `createTCPMonitor(request)`
 
 Create a TCP connection monitor.
 
 ```typescript
-const { monitor } = await openstatus.monitor.v1.MonitorService.createTCPMonitor(
-  {
-    monitor: {
-      name: "Database",
-      uri: "db.example.com:5432",
-      periodicity: Periodicity.PERIODICITY_5M,
-      regions: [Region.FLY_AMS, Region.FLY_IAD],
-      active: true,
-    },
+const { monitor } = await client.monitor.v1.MonitorService.createTCPMonitor({
+  monitor: {
+    name: "Database",
+    uri: "db.example.com:5432",
+    periodicity: Periodicity.PERIODICITY_5M,
+    regions: [Region.FLY_AMS, Region.FLY_IAD],
+    active: true,
   },
-  { headers },
-);
+});
 ```
 
-#### `updateTCPMonitor(request, options)`
+#### `updateTCPMonitor(request)`
 
 Update an existing TCP monitor.
 
 ```typescript
-const { monitor } = await openstatus.monitor.v1.MonitorService.updateTCPMonitor(
-  {
-    id: "mon_123",
-    monitor: {
-      name: "Updated Database Monitor",
-    },
+const { monitor } = await client.monitor.v1.MonitorService.updateTCPMonitor({
+  id: "mon_123",
+  monitor: {
+    name: "Updated Database Monitor",
   },
-  { headers },
-);
+});
 ```
 
-#### `createDNSMonitor(request, options)`
+#### `createDNSMonitor(request)`
 
 Create a DNS resolution monitor.
 
 ```typescript
 import { Periodicity, RecordComparator, Region } from "@openstatus/sdk-node";
 
-const { monitor } = await openstatus.monitor.v1.MonitorService.createDNSMonitor(
-  {
-    monitor: {
-      name: "DNS Check",
-      uri: "example.com",
-      periodicity: Periodicity.PERIODICITY_10M,
-      regions: [Region.FLY_AMS],
-      active: true,
-      recordAssertions: [
-        {
-          record: "A",
-          comparator: RecordComparator.EQUAL,
-          target: "93.184.216.34",
-        },
-      ],
-    },
+const { monitor } = await client.monitor.v1.MonitorService.createDNSMonitor({
+  monitor: {
+    name: "DNS Check",
+    uri: "example.com",
+    periodicity: Periodicity.PERIODICITY_10M,
+    regions: [Region.FLY_AMS],
+    active: true,
+    recordAssertions: [
+      {
+        record: "A",
+        comparator: RecordComparator.EQUAL,
+        target: "93.184.216.34",
+      },
+    ],
   },
-  { headers },
-);
+});
 ```
 
-#### `updateDNSMonitor(request, options)`
+#### `updateDNSMonitor(request)`
 
 Update an existing DNS monitor.
 
 ```typescript
-const { monitor } = await openstatus.monitor.v1.MonitorService.updateDNSMonitor(
-  {
-    id: "mon_123",
-    monitor: {
-      name: "Updated DNS Check",
-    },
+const { monitor } = await client.monitor.v1.MonitorService.updateDNSMonitor({
+  id: "mon_123",
+  monitor: {
+    name: "Updated DNS Check",
   },
-  { headers },
-);
+});
 ```
 
-#### `listMonitors(request, options)`
+#### `listMonitors(request)`
 
 List all monitors with pagination. Returns monitors grouped by type.
 
 ```typescript
 const { httpMonitors, tcpMonitors, dnsMonitors, nextPageToken, totalSize } =
-  await openstatus.monitor.v1.MonitorService.listMonitors(
-    { pageSize: 10, pageToken: "" },
-    { headers },
-  );
+  await client.monitor.v1.MonitorService.listMonitors({
+    pageSize: 10,
+    pageToken: "",
+  });
 ```
 
-#### `triggerMonitor(request, options)`
+#### `triggerMonitor(request)`
 
 Trigger an immediate check.
 
 ```typescript
-const { success } = await openstatus.monitor.v1.MonitorService.triggerMonitor(
-  { id: "mon_123" },
-  { headers },
-);
+const { success } = await client.monitor.v1.MonitorService.triggerMonitor({
+  id: "mon_123",
+});
 ```
 
-#### `deleteMonitor(request, options)`
+#### `deleteMonitor(request)`
 
 Delete a monitor.
 
 ```typescript
-const { success } = await openstatus.monitor.v1.MonitorService.deleteMonitor(
-  { id: "mon_123" },
-  { headers },
-);
+const { success } = await client.monitor.v1.MonitorService.deleteMonitor({
+  id: "mon_123",
+});
 ```
 
-#### `getMonitorStatus(request, options)`
+#### `getMonitorStatus(request)`
 
 Get the current status of a monitor across all configured regions.
 
 ```typescript
 import { MonitorStatus, Region } from "@openstatus/sdk-node";
 
-const { id, regions } = await openstatus.monitor.v1.MonitorService.getMonitorStatus(
+const { id, regions } = await client.monitor.v1.MonitorService.getMonitorStatus(
   { id: "mon_123" },
-  { headers },
 );
 
 for (const { region, status } of regions) {
···
 }
 ```
 
-#### `getMonitorSummary(request, options)`
+#### `getMonitorSummary(request)`
 
 Get aggregated metrics and latency percentiles for a monitor.
 
 ```typescript
 import { TimeRange } from "@openstatus/sdk-node";
 
-const summary = await openstatus.monitor.v1.MonitorService.getMonitorSummary(
-  {
-    id: "mon_123",
-    timeRange: TimeRange.TIME_RANGE_7D,
-    regions: [], // optional: filter by specific regions
-  },
-  { headers },
-);
+const summary = await client.monitor.v1.MonitorService.getMonitorSummary({
+  id: "mon_123",
+  timeRange: TimeRange.TIME_RANGE_7D,
+  regions: [], // optional: filter by specific regions
+});
 
 console.log(`Last ping: ${summary.lastPingAt}`);
 console.log(`Success: ${summary.totalSuccessful}`);
···
 Check API health status (no authentication required).
 
 ```typescript
-import { ServingStatus } from "@openstatus/sdk-node";
+import { openstatus, ServingStatus } from "@openstatus/sdk-node";
 
 const { status } = await openstatus.health.v1.HealthService.check({});
 console.log(ServingStatus[status]); // "SERVING"
···
 
 Manage incident reports with update timelines.
 
-#### `createStatusReport(request, options)`
+#### `createStatusReport(request)`
 
 Create a new status report.
 
 ```typescript
 import { StatusReportStatus } from "@openstatus/sdk-node";
 
-const { statusReport } = await openstatus.statusReport.v1.StatusReportService.createStatusReport(
-  {
+const { statusReport } = await client.statusReport.v1.StatusReportService
+  .createStatusReport({
     title: "API Degradation",
     status: StatusReportStatus.INVESTIGATING,
     message: "We are investigating reports of increased latency.",
···
     pageId: "page_123",
     pageComponentIds: ["comp_456"],
     notify: true,
-  },
-  { headers },
-);
+  });
 
 console.log(`Status report created: ${statusReport?.id}`);
 ```
 
-#### `getStatusReport(request, options)`
+#### `getStatusReport(request)`
 
 Get a status report by ID (includes full update timeline).
 
 ```typescript
 import { StatusReportStatus } from "@openstatus/sdk-node";
 
-const { statusReport } = await openstatus.statusReport.v1.StatusReportService.getStatusReport(
-  { id: "sr_123" },
-  { headers },
-);
+const { statusReport } = await client.statusReport.v1.StatusReportService
+  .getStatusReport({
+    id: "sr_123",
+  });
 
 console.log(`Title: ${statusReport?.title}`);
 console.log(`Status: ${StatusReportStatus[statusReport?.status ?? 0]}`);
···
 }
 ```
 
-#### `listStatusReports(request, options)`
+#### `listStatusReports(request)`
 
 List all status reports with pagination and optional filtering.
 
 ```typescript
 import { StatusReportStatus } from "@openstatus/sdk-node";
 
-const { statusReports, totalSize } =
-  await openstatus.statusReport.v1.StatusReportService.listStatusReports(
-    {
-      limit: 10,
-      offset: 0,
-      statuses: [StatusReportStatus.INVESTIGATING, StatusReportStatus.IDENTIFIED],
-    },
-    { headers },
-  );
+const { statusReports, totalSize } = await client.statusReport.v1
+  .StatusReportService.listStatusReports({
+    limit: 10,
+    offset: 0,
+    statuses: [StatusReportStatus.INVESTIGATING, StatusReportStatus.IDENTIFIED],
+  });
 
 console.log(`Found ${totalSize} status reports`);
 ```
 
-#### `updateStatusReport(request, options)`
+#### `updateStatusReport(request)`
 
 Update status report metadata.
 
 ```typescript
-const { statusReport } = await openstatus.statusReport.v1.StatusReportService.updateStatusReport(
-  {
+const { statusReport } = await client.statusReport.v1.StatusReportService
+  .updateStatusReport({
     id: "sr_123",
     title: "Updated Title",
     pageComponentIds: ["comp_456", "comp_789"],
-  },
-  { headers },
-);
+  });
 ```
 
-#### `deleteStatusReport(request, options)`
+#### `deleteStatusReport(request)`
 
 Delete a status report and all its updates.
 
 ```typescript
-const { success } = await openstatus.statusReport.v1.StatusReportService.deleteStatusReport(
-  { id: "sr_123" },
-  { headers },
-);
+const { success } = await client.statusReport.v1.StatusReportService
+  .deleteStatusReport({
+    id: "sr_123",
+  });
 ```
 
-#### `addStatusReportUpdate(request, options)`
+#### `addStatusReportUpdate(request)`
 
 Add a new update to an existing status report timeline.
 
 ```typescript
 import { StatusReportStatus } from "@openstatus/sdk-node";
 
-const { statusReport } = await openstatus.statusReport.v1.StatusReportService.addStatusReportUpdate(
-  {
+const { statusReport } = await client.statusReport.v1.StatusReportService
+  .addStatusReportUpdate({
     statusReportId: "sr_123",
     status: StatusReportStatus.IDENTIFIED,
     message: "The issue has been identified as a database connection problem.",
     date: "2024-01-15T11:00:00Z", // optional, defaults to current time
     notify: true,
-  },
-  { headers },
-);
+  });
 ```
 
 ---
···
 
 Manage status pages, components, and subscribers.
 
-#### `createStatusPage(request, options)`
+#### `createStatusPage(request)`
 
 Create a new status page.
 
 ```typescript
-const { statusPage } = await openstatus.statusPage.v1.StatusPageService.createStatusPage(
-  {
+const { statusPage } = await client.statusPage.v1.StatusPageService
+  .createStatusPage({
     title: "My Service Status",
     slug: "my-service",
     description: "Status page for My Service",
     homepageUrl: "https://example.com",
     contactUrl: "https://example.com/contact",
-  },
-  { headers },
-);
+  });
 
 console.log(`Status page created: ${statusPage?.id}`);
 ```
 
-#### `getStatusPage(request, options)`
+#### `getStatusPage(request)`
 
 Get a status page by ID.
 
 ```typescript
-const { statusPage } = await openstatus.statusPage.v1.StatusPageService.getStatusPage(
-  { id: "page_123" },
-  { headers },
-);
+const { statusPage } = await client.statusPage.v1.StatusPageService
+  .getStatusPage({
+    id: "page_123",
+  });
 ```
 
-#### `listStatusPages(request, options)`
+#### `listStatusPages(request)`
 
 List all status pages with pagination.
 
 ```typescript
-const { statusPages, totalSize } =
-  await openstatus.statusPage.v1.StatusPageService.listStatusPages(
-    { limit: 10, offset: 0 },
-    { headers },
-  );
+const { statusPages, totalSize } = await client.statusPage.v1.StatusPageService
+  .listStatusPages({ limit: 10, offset: 0 });
 
 console.log(`Found ${totalSize} status pages`);
 ```
 
-#### `updateStatusPage(request, options)`
+#### `updateStatusPage(request)`
 
 Update a status page.
 
 ```typescript
-const { statusPage } = await openstatus.statusPage.v1.StatusPageService.updateStatusPage(
-  {
+const { statusPage } = await client.statusPage.v1.StatusPageService
+  .updateStatusPage({
     id: "page_123",
     title: "Updated Title",
     description: "Updated description",
-  },
-  { headers },
-);
+  });
 ```
 
-#### `deleteStatusPage(request, options)`
+#### `deleteStatusPage(request)`
 
 Delete a status page.
 
 ```typescript
-const { success } = await openstatus.statusPage.v1.StatusPageService.deleteStatusPage(
-  { id: "page_123" },
-  { headers },
-);
+const { success } = await client.statusPage.v1.StatusPageService
+  .deleteStatusPage({
+    id: "page_123",
+  });
 ```
 
-#### `addMonitorComponent(request, options)`
+#### `addMonitorComponent(request)`
 
 Add a monitor-based component to a status page.
 
 ```typescript
-const { component } = await openstatus.statusPage.v1.StatusPageService.addMonitorComponent(
-  {
+const { component } = await client.statusPage.v1.StatusPageService
+  .addMonitorComponent({
     pageId: "page_123",
     monitorId: "mon_456",
     name: "API Server",
     description: "Main API endpoint",
     order: 1,
-  },
-  { headers },
-);
+  });
 ```
 
-#### `addStaticComponent(request, options)`
+#### `addStaticComponent(request)`
 
 Add a static component (not linked to a monitor).
 
 ```typescript
-const { component } = await openstatus.statusPage.v1.StatusPageService.addStaticComponent(
-  {
+const { component } = await client.statusPage.v1.StatusPageService
+  .addStaticComponent({
     pageId: "page_123",
     name: "Third-party Service",
     description: "External dependency",
     order: 2,
-  },
-  { headers },
-);
+  });
 ```
 
-#### `updateComponent(request, options)`
+#### `updateComponent(request)`
 
 Update a component.
 
 ```typescript
-const { component } = await openstatus.statusPage.v1.StatusPageService.updateComponent(
-  {
+const { component } = await client.statusPage.v1.StatusPageService
+  .updateComponent({
     id: "comp_123",
     name: "Updated Component Name",
     order: 3,
-  },
-  { headers },
-);
+  });
 ```
 
-#### `removeComponent(request, options)`
+#### `removeComponent(request)`
 
 Remove a component from a status page.
 
 ```typescript
-const { success } = await openstatus.statusPage.v1.StatusPageService.removeComponent(
-  { id: "comp_123" },
-  { headers },
-);
+const { success } = await client.statusPage.v1.StatusPageService
+  .removeComponent({
+    id: "comp_123",
+  });
 ```
 
-#### `createComponentGroup(request, options)`
+#### `createComponentGroup(request)`
 
 Create a component group.
 
 ```typescript
-const { group } = await openstatus.statusPage.v1.StatusPageService.createComponentGroup(
-  {
+const { group } = await client.statusPage.v1.StatusPageService
+  .createComponentGroup({
     pageId: "page_123",
     name: "Core Services",
-  },
-  { headers },
-);
+  });
 ```
 
-#### `updateComponentGroup(request, options)`
+#### `updateComponentGroup(request)`
 
 Update a component group.
 
 ```typescript
-const { group } = await openstatus.statusPage.v1.StatusPageService.updateComponentGroup(
-  {
+const { group } = await client.statusPage.v1.StatusPageService
+  .updateComponentGroup({
     id: "group_123",
     name: "Updated Group Name",
-  },
-  { headers },
-);
+  });
 ```
 
-#### `deleteComponentGroup(request, options)`
+#### `deleteComponentGroup(request)`
 
 Delete a component group.
 
 ```typescript
-const { success } = await openstatus.statusPage.v1.StatusPageService.deleteComponentGroup(
-  { id: "group_123" },
-  { headers },
-);
+const { success } = await client.statusPage.v1.StatusPageService
+  .deleteComponentGroup({
+    id: "group_123",
+  });
 ```
 
-#### `subscribeToPage(request, options)`
+#### `subscribeToPage(request)`
 
 Subscribe an email to status page updates.
 
 ```typescript
-const { subscriber } = await openstatus.statusPage.v1.StatusPageService.subscribeToPage(
-  {
+const { subscriber } = await client.statusPage.v1.StatusPageService
+  .subscribeToPage({
     pageId: "page_123",
     email: "[e-mail]",
-  },
-  { headers },
-);
+  });
 ```
 
-#### `unsubscribeFromPage(request, options)`
+#### `unsubscribeFromPage(request)`
 
 Unsubscribe from a status page.
 
 ```typescript
 // By email
-const { success } = await openstatus.statusPage.v1.StatusPageService.unsubscribeFromPage(
-  {
+const { success } = await client.statusPage.v1.StatusPageService
+  .unsubscribeFromPage({
     pageId: "page_123",
     identifier: { case: "email", value: "[e-mail]" },
-  },
-  { headers },
-);
+  });
 
 // Or by subscriber ID
-const { success: success2 } = await openstatus.statusPage.v1.StatusPageService.unsubscribeFromPage(
-  {
+const { success: success2 } = await client.statusPage.v1.StatusPageService
+  .unsubscribeFromPage({
     pageId: "page_123",
     identifier: { case: "id", value: "sub_456" },
-  },
-  { headers },
-);
+  });
 ```
 
-#### `listSubscribers(request, options)`
+#### `listSubscribers(request)`
 
 List all subscribers for a status page.
 
 ```typescript
-const { subscribers, totalSize } =
-  await openstatus.statusPage.v1.StatusPageService.listSubscribers(
-    {
-      pageId: "page_123",
-      limit: 50,
-      offset: 0,
-      includeUnsubscribed: false,
-    },
-    { headers },
-  );
+const { subscribers, totalSize } = await client.statusPage.v1.StatusPageService
+  .listSubscribers({
+    pageId: "page_123",
+    limit: 50,
+    offset: 0,
+    includeUnsubscribed: false,
+  });
 ```
 
-#### `getStatusPageContent(request, options)`
+#### `getStatusPageContent(request)`
 
 Get full status page content including components, groups, and active reports.
 
 ```typescript
-const content = await openstatus.statusPage.v1.StatusPageService.getStatusPageContent(
-  { identifier: { case: "slug", value: "my-service" } },
-  { headers },
-);
+const content = await client.statusPage.v1.StatusPageService
+  .getStatusPageContent({
+    identifier: { case: "slug", value: "my-service" },
+  });
 
 console.log(`Page: ${content.statusPage?.title}`);
 console.log(`Components: ${content.components.length}`);
 console.log(`Active reports: ${content.statusReports.length}`);
 ```
 
-#### `getOverallStatus(request, options)`
+#### `getOverallStatus(request)`
 
 Get the aggregated status of a status page.
 
 ```typescript
 import { OverallStatus } from "@openstatus/sdk-node";
 
-const { overallStatus, componentStatuses } =
-  await openstatus.statusPage.v1.StatusPageService.getOverallStatus(
-    { identifier: { case: "id", value: "page_123" } },
-    { headers },
-  );
+const { overallStatus, componentStatuses } = await client.statusPage.v1
+  .StatusPageService.getOverallStatus({
+    identifier: { case: "id", value: "page_123" },
+  });
 
 console.log(`Overall: ${OverallStatus[overallStatus]}`);
 for (const { componentId, status } of componentStatuses) {
···
 
 Manage scheduled maintenance windows.
 
-#### `createMaintenance(request, options)`
+#### `createMaintenance(request)`
 
 Create a new maintenance window.
 
 ```typescript
-const { maintenance } = await openstatus.maintenance.v1.MaintenanceService.createMaintenance(
-  {
+const { maintenance } = await client.maintenance.v1.MaintenanceService
+  .createMaintenance({
     title: "Database Upgrade",
     message: "We will be upgrading our database infrastructure.",
     from: "2024-01-20T02:00:00Z",
···
     pageId: "page_123",
     pageComponentIds: ["comp_456"],
     notify: true,
-  },
-  { headers },
-);
+  });
 
 console.log(`Maintenance created: ${maintenance?.id}`);
 ```
 
-#### `getMaintenance(request, options)`
+#### `getMaintenance(request)`
 
 Get a maintenance window by ID.
 
 ```typescript
-const { maintenance } = await openstatus.maintenance.v1.MaintenanceService.getMaintenance(
-  { id: "maint_123" },
-  { headers },
-);
+const { maintenance } = await client.maintenance.v1.MaintenanceService
+  .getMaintenance({
+    id: "maint_123",
+  });
 
 console.log(`Title: ${maintenance?.title}`);
 console.log(`From: ${maintenance?.from}`);
 console.log(`To: ${maintenance?.to}`);
 ```
 
-#### `listMaintenances(request, options)`
+#### `listMaintenances(request)`
 
 List all maintenance windows with pagination and optional filtering.
 
 ```typescript
-const { maintenances, totalSize } =
-  await openstatus.maintenance.v1.MaintenanceService.listMaintenances(
-    {
-      limit: 10,
-      offset: 0,
-      pageId: "page_123", // optional filter
-    },
-    { headers },
-  );
+const { maintenances, totalSize } = await client.maintenance.v1
+  .MaintenanceService.listMaintenances({
+    limit: 10,
+    offset: 0,
+    pageId: "page_123", // optional filter
+  });
 
 console.log(`Found ${totalSize} maintenance windows`);
 ```
 
-#### `updateMaintenance(request, options)`
+#### `updateMaintenance(request)`
 
 Update a maintenance window.
 
 ```typescript
-const { maintenance } = await openstatus.maintenance.v1.MaintenanceService.updateMaintenance(
-  {
+const { maintenance } = await client.maintenance.v1.MaintenanceService
+  .updateMaintenance({
     id: "maint_123",
     title: "Extended Database Upgrade",
     to: "2024-01-20T06:00:00Z",
-  },
-  { headers },
-);
+  });
 ```
 
-#### `deleteMaintenance(request, options)`
+#### `deleteMaintenance(request)`
 
 Delete a maintenance window.
 
 ```typescript
-const { success } = await openstatus.maintenance.v1.MaintenanceService.deleteMaintenance(
-  { id: "maint_123" },
-  { headers },
-);
+const { success } = await client.maintenance.v1.MaintenanceService
+  .deleteMaintenance({
+    id: "maint_123",
+  });
 ```
 
 ---
···
 Manage notification channels for monitor alerts. Supports 12 providers including
 Slack, Discord, Email, PagerDuty, and custom webhooks.
 
-#### `createNotification(request, options)`
+#### `createNotification(request)`
 
 Create a new notification channel.
 
 ```typescript
 import { NotificationProvider } from "@openstatus/sdk-node";
 
-const { notification } = await openstatus.notification.v1.NotificationService.createNotification(
-  {
+const { notification } = await client.notification.v1.NotificationService
+  .createNotification({
     name: "Slack Alerts",
     provider: NotificationProvider.SLACK,
     data: {
···
       },
     },
     monitorIds: ["mon_123", "mon_456"],
-  },
-  { headers },
-);
+  });
 
 console.log(`Notification created: ${notification?.id}`);
 ```
 
-#### `getNotification(request, options)`
+#### `getNotification(request)`
 
 Get a notification channel by ID.
 
 ```typescript
 import { NotificationProvider } from "@openstatus/sdk-node";
 
-const { notification } = await openstatus.notification.v1.NotificationService.getNotification(
-  { id: "notif_123" },
-  { headers },
-);
+const { notification } = await client.notification.v1.NotificationService
+  .getNotification({
+    id: "notif_123",
+  });
 
 console.log(`Name: ${notification?.name}`);
 console.log(`Provider: ${NotificationProvider[notification?.provider ?? 0]}`);
 ```
 
-#### `listNotifications(request, options)`
+#### `listNotifications(request)`
 
 List all notification channels with pagination.
 
 ```typescript
-const { notifications, totalSize } =
-  await openstatus.notification.v1.NotificationService.listNotifications(
-    { limit: 10, offset: 0 },
-    { headers },
-  );
+const { notifications, totalSize } = await client.notification.v1
+  .NotificationService.listNotifications({ limit: 10, offset: 0 });
 
 console.log(`Found ${totalSize} notification channels`);
 ```
 
-#### `updateNotification(request, options)`
+#### `updateNotification(request)`
 
 Update a notification channel.
 
 ```typescript
-const { notification } = await openstatus.notification.v1.NotificationService.updateNotification(
-  {
+const { notification } = await client.notification.v1.NotificationService
+  .updateNotification({
     id: "notif_123",
     name: "Updated Slack Alerts",
     monitorIds: ["mon_123", "mon_456", "mon_789"],
-  },
-  { headers },
-);
+  });
 ```
 
-#### `deleteNotification(request, options)`
+#### `deleteNotification(request)`
 
 Delete a notification channel.
 
 ```typescript
-const { success } = await openstatus.notification.v1.NotificationService.deleteNotification(
-  { id: "notif_123" },
-  { headers },
-);
+const { success } = await client.notification.v1.NotificationService
+  .deleteNotification({
+    id: "notif_123",
+  });
 ```
 
-#### `sendTestNotification(request, options)`
+#### `sendTestNotification(request)`
 
 Send a test notification to verify configuration.
 
 ```typescript
 import { NotificationProvider } from "@openstatus/sdk-node";
 
-const { success, errorMessage } =
-  await openstatus.notification.v1.NotificationService.sendTestNotification(
-    {
-      provider: NotificationProvider.SLACK,
+const { success, errorMessage } = await client.notification.v1
+  .NotificationService.sendTestNotification({
+    provider: NotificationProvider.SLACK,
+    data: {
       data: {
-        data: {
-          case: "slack",
-          value: { webhookUrl: "https://hooks.slack.com/services/..." },
-        },
+        case: "slack",
+        value: { webhookUrl: "https://hooks.slack.com/services/..." },
       },
     },
-    { headers },
-  );
+  });
 
 if (success) {
   console.log("Test notification sent successfully");
···
 }
 ```
 
-#### `checkNotificationLimit(request, options)`
+#### `checkNotificationLimit(request)`
 
 Check if the workspace has reached its notification limit.
 
 ```typescript
-const { limitReached, currentCount, maxCount } =
-  await openstatus.notification.v1.NotificationService.checkNotificationLimit({}, { headers });
+const { limitReached, currentCount, maxCount } = await client.notification.v1
+  .NotificationService.checkNotificationLimit({});
 
 console.log(`${currentCount}/${maxCount} notification channels used`);
 ```
···
 
 #### HTTP Monitor
 
-| Option                 | Type                | Required | Description                                |
-| ---------------------- | ------------------- | -------- | ------------------------------------------ |
-| `name`                 | string              | Yes      | Monitor name (max 256 chars)               |
-| `url`                  | string              | Yes      | URL to monitor (max 2048 chars)            |
-| `periodicity`          | Periodicity         | Yes      | Check interval                             |
-| `method`               | HTTPMethod          | No       | HTTP method (default: GET)                 |
-| `body`                 | string              | No       | Request body                               |
-| `headers`              | Headers[]           | No       | Custom headers `{ key, value }[]`          |
-| `timeout`              | bigint              | No       | Timeout in ms (default: 45000, max: 120000)|
-| `retry`                | bigint              | No       | Retry attempts (default: 3, max: 10)       |
-| `followRedirects`      | boolean             | No       | Follow redirects (default: true)           |
-| `regions`              | Region[]            | No       | Regions for checks                         |
-| `active`               | boolean             | No       | Enable monitoring (default: false)         |
-| `public`               | boolean             | No       | Public visibility (default: false)         |
-| `degradedAt`           | bigint              | No       | Latency threshold (ms) for degraded status |
-| `description`          | string              | No       | Monitor description (max 1024 chars)       |
-| `statusCodeAssertions` | array               | No       | Status code assertions                     |
-| `bodyAssertions`       | array               | No       | Body assertions                            |
-| `headerAssertions`     | array               | No       | Header assertions                          |
-| `openTelemetry`        | OpenTelemetryConfig | No       | OpenTelemetry export configuration         |
+| Option                 | Type                | Required | Description                                 |
+| ---------------------- | ------------------- | -------- | ------------------------------------------- |
+| `name`                 | string              | Yes      | Monitor name (max 256 chars)                |
+| `url`                  | string              | Yes      | URL to monitor (max 2048 chars)             |
+| `periodicity`          | Periodicity         | Yes      | Check interval                              |
+| `method`               | HTTPMethod          | No       | HTTP method (default: GET)                  |
+| `body`                 | string              | No       | Request body                                |
+| `headers`              | Headers[]           | No       | Custom headers `{ key, value }[]`           |
+| `timeout`              | bigint              | No       | Timeout in ms (default: 45000, max: 120000) |
+| `retry`                | bigint              | No       | Retry attempts (default: 3, max: 10)        |
+| `followRedirects`      | boolean             | No       | Follow redirects (default: true)            |
+| `regions`              | Region[]            | No       | Regions for checks                          |
+| `active`               | boolean             | No       | Enable monitoring (default: false)          |
+| `public`               | boolean             | No       | Public visibility (default: false)          |
+| `degradedAt`           | bigint              | No       | Latency threshold (ms) for degraded status  |
+| `description`          | string              | No       | Monitor description (max 1024 chars)        |
+| `statusCodeAssertions` | array               | No       | Status code assertions                      |
+| `bodyAssertions`       | array               | No       | Body assertions                             |
+| `headerAssertions`     | array               | No       | Header assertions                           |
+| `openTelemetry`        | OpenTelemetryConfig | No       | OpenTelemetry export configuration          |
 
 #### TCP Monitor
 
-| Option          | Type                | Required | Description                                |
-| --------------- | ------------------- | -------- | ------------------------------------------ |
-| `name`          | string              | Yes      | Monitor name (max 256 chars)               |
-| `uri`           | string              | Yes      | `host:port` to monitor (max 2048 chars)    |
-| `periodicity`   | Periodicity         | Yes      | Check interval                             |
-| `timeout`       | bigint              | No       | Timeout in ms (default: 45000, max: 120000)|
-| `retry`         | bigint              | No       | Retry attempts (default: 3, max: 10)       |
-| `regions`       | Region[]            | No       | Regions for checks                         |
-| `active`        | boolean             | No       | Enable monitoring (default: false)         |
-| `public`        | boolean             | No       | Public visibility (default: false)         |
-| `degradedAt`    | bigint              | No       | Latency threshold (ms) for degraded status |
-| `description`   | string              | No       | Monitor description (max 1024 chars)       |
-| `openTelemetry` | OpenTelemetryConfig | No       | OpenTelemetry export configuration         |
+| Option          | Type                | Required | Description                                 |
+| --------------- | ------------------- | -------- | ------------------------------------------- |
+| `name`          | string              | Yes      | Monitor name (max 256 chars)                |
+| `uri`           | string              | Yes      | `host:port` to monitor (max 2048 chars)     |
+| `periodicity`   | Periodicity         | Yes      | Check interval                              |
+| `timeout`       | bigint              | No       | Timeout in ms (default: 45000, max: 120000) |
+| `retry`         | bigint              | No       | Retry attempts (default: 3, max: 10)        |
+| `regions`       | Region[]            | No       | Regions for checks                          |
+| `active`        | boolean             | No       | Enable monitoring (default: false)          |
+| `public`        | boolean             | No       | Public visibility (default: false)          |
+| `degradedAt`    | bigint              | No       | Latency threshold (ms) for degraded status  |
+| `description`   | string              | No       | Monitor description (max 1024 chars)        |
+| `openTelemetry` | OpenTelemetryConfig | No       | OpenTelemetry export configuration          |
 
 #### DNS Monitor
 
-| Option             | Type                | Required | Description                                |
-| ------------------ | ------------------- | -------- | ------------------------------------------ |
-| `name`             | string              | Yes      | Monitor name (max 256 chars)               |
-| `uri`              | string              | Yes      | Domain to resolve (max 2048 chars)         |
-| `periodicity`      | Periodicity         | Yes      | Check interval                             |
-| `timeout`          | bigint              | No       | Timeout in ms (default: 45000, max: 120000)|
-| `retry`            | bigint              | No       | Retry attempts (default: 3, max: 10)       |
-| `regions`          | Region[]            | No       | Regions for checks                         |
-| `active`           | boolean             | No       | Enable monitoring (default: false)         |
-| `public`           | boolean             | No       | Public visibility (default: false)         |
-| `degradedAt`       | bigint              | No       | Latency threshold (ms) for degraded status |
-| `description`      | string              | No       | Monitor description (max 1024 chars)       |
-| `recordAssertions` | array               | No       | DNS record assertions                      |
-| `openTelemetry`    | OpenTelemetryConfig | No       | OpenTelemetry export configuration         |
+| Option             | Type                | Required | Description                                 |
+| ------------------ | ------------------- | -------- | ------------------------------------------- |
+| `name`             | string              | Yes      | Monitor name (max 256 chars)                |
+| `uri`              | string              | Yes      | Domain to resolve (max 2048 chars)          |
+| `periodicity`      | Periodicity         | Yes      | Check interval                              |
+| `timeout`          | bigint              | No       | Timeout in ms (default: 45000, max: 120000) |
+| `retry`            | bigint              | No       | Retry attempts (default: 3, max: 10)        |
+| `regions`          | Region[]            | No       | Regions for checks                          |
+| `active`           | boolean             | No       | Enable monitoring (default: false)          |
+| `public`           | boolean             | No       | Public visibility (default: false)          |
+| `degradedAt`       | bigint              | No       | Latency threshold (ms) for degraded status  |
+| `description`      | string              | No       | Monitor description (max 1024 chars)        |
+| `recordAssertions` | array               | No       | DNS record assertions                       |
+| `openTelemetry`    | OpenTelemetryConfig | No       | OpenTelemetry export configuration          |
 
 ---
 
···
 
 #### MonitorStatus
 
-| Value      | Description              |
-| ---------- | ------------------------ |
-| `ACTIVE`   | Monitor is healthy       |
+| Value      | Description                |
+| ---------- | -------------------------- |
+| `ACTIVE`   | Monitor is healthy         |
 | `DEGRADED` | Latency threshold exceeded |
-| `ERROR`    | Monitor is failing       |
+| `ERROR`    | Monitor is failing         |
 
 #### TimeRange
 
-| Value             | Description |
-| ----------------- | ----------- |
-| `TIME_RANGE_1D`   | Last 1 day  |
-| `TIME_RANGE_7D`   | Last 7 days |
-| `TIME_RANGE_14D`  | Last 14 days|
+| Value            | Description  |
+| ---------------- | ------------ |
+| `TIME_RANGE_1D`  | Last 1 day   |
+| `TIME_RANGE_7D`  | Last 7 days  |
+| `TIME_RANGE_14D` | Last 14 days |
 
 #### StatusReportStatus
 
···
 import { ConnectError } from "@connectrpc/connect";
 
 try {
-  await openstatus.monitor.v1.MonitorService.deleteMonitor(
-    { id: "invalid" },
-    { headers },
-  );
+  await client.monitor.v1.MonitorService.deleteMonitor({ id: "invalid" });
 } catch (error) {
   if (error instanceof ConnectError) {
     console.error(`Error ${error.code}: ${error.message}`);

deno-example.ts

···
+import { createOpenStatusClient } from "@openstatus/sdk-node";
+
+const apiKey = Deno.env.get("OPENSTATUS_API_KEY");
+
+const client = createOpenStatusClient({
+  apiKey: apiKey,
+});
+
+const monitors = await client.monitor.v1.MonitorService.listMonitors({});
+
+console.log(monitors);
+
+const notification = await client.notification.v1.NotificationService
+  .listNotifications({});
+
+console.log(notification);

src/mod.ts

···
  *
  * Official Node.js SDK for OpenStatus - the open-source monitoring platform.
  *
- * @example Basic usage
+ * @example Basic usage (recommended)
  * ```typescript
- * import { openstatus, Periodicity, Region } from "@openstatus/sdk-node";
+ * import { createOpenStatusClient, Periodicity, Region } from "@openstatus/sdk-node";
  *
- * const headers = {
- *   "x-openstatus-key": `Bearer ${process.env.OPENSTATUS_API_KEY}`,
- * };
+ * // Create a client with your API key
+ * const client = createOpenStatusClient({
+ *   apiKey: process.env.OPENSTATUS_API_KEY,
+ * });
  *
- * // List all monitors
+ * // List all monitors - no need to pass headers
  * const { httpMonitors, tcpMonitors, dnsMonitors } =
- *   await openstatus.monitor.v1.MonitorService.listMonitors({}, { headers });
+ *   await client.monitor.v1.MonitorService.listMonitors({});
  *
  * // Create an HTTP monitor
- * const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor({
+ * const { monitor } = await client.monitor.v1.MonitorService.createHTTPMonitor({
  *   monitor: {
  *     name: "My API",
  *     url: "https://api.example.com/health",
···
  *     regions: [Region.FLY_AMS, Region.FLY_IAD, Region.FLY_SYD],
  *     active: true,
  *   },
+ * });
+ * ```
+ *
+ * @example Alternative: Manual headers
+ * ```typescript
+ * import { openstatus, Periodicity } from "@openstatus/sdk-node";
+ *
+ * const headers = { "x-openstatus-key": `Bearer ${process.env.OPENSTATUS_API_KEY}` };
+ * const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor({
+ *   monitor: { name: "My API", url: "https://api.example.com", periodicity: Periodicity.PERIODICITY_1M, active: true },
  * }, { headers });
  * ```
  */
 
-import type { Client } from "@connectrpc/connect";
+import type { Client, Interceptor } from "@connectrpc/connect";
 import { createClient } from "@connectrpc/connect";
 import { createConnectTransport } from "@connectrpc/connect-node";
 import { MonitorService } from "./gen/openstatus/monitor/v1/service_pb.ts";
···
 const DEFAULT_API_URL = "https://api.openstatus.dev/rpc";
 
 /**
+ * Configuration options for creating an OpenStatus client.
+ */
+export interface OpenStatusClientOptions {
+  /**
+   * Your OpenStatus API key.
+   * If provided, it will be automatically included in all requests.
+   */
+  apiKey?: string;
+  /**
+   * Custom API base URL. Defaults to the OpenStatus production API.
+   */
+  baseUrl?: string;
+}
+
+/**
+ * Creates an interceptor that adds the API key header to all requests.
+ */
+function createAuthInterceptor(apiKey: string): Interceptor {
+  return (next) => (req) => {
+    req.header.set("x-openstatus-key", `${apiKey}`);
+    return next(req);
+  };
+}
+
+/**
  * Creates a Connect RPC transport configured for the OpenStatus API.
  */
-const transport = createConnectTransport({
-  baseUrl: process.env.OPENSTATUS_API_URL ?? DEFAULT_API_URL,
-  httpVersion: "2",
-});
+function createTransport(options?: OpenStatusClientOptions) {
+  const interceptors: Interceptor[] = [];
+
+  if (options?.apiKey) {
+    interceptors.push(createAuthInterceptor(options.apiKey));
+  }
+
+  return createConnectTransport({
+    baseUrl: options?.baseUrl ?? process.env.OPENSTATUS_API_URL ??
+      DEFAULT_API_URL,
+    httpVersion: "2",
+    interceptors,
+  });
+}
 
 /**
  * OpenStatus API client interface.
···
 }
 
 /**
- * OpenStatus SDK client.
+ * Creates a configured OpenStatus client with optional API key authentication.
  *
- * Provides access to the OpenStatus API for managing monitors and checking service health.
+ * Use this factory function to create a client that automatically includes
+ * your API key in all requests, eliminating the need to pass headers manually.
  *
  * @example
  * ```typescript
- * import { openstatus, Periodicity } from "@openstatus/sdk-node";
+ * import { createOpenStatusClient, Periodicity, Region } from "@openstatus/sdk-node";
+ *
+ * // Create a configured client
+ * const client = createOpenStatusClient({
+ *   apiKey: process.env.OPENSTATUS_API_KEY,
+ * });
  *
- * // Check API health (no auth required)
- * const { status } = await openstatus.health.v1.HealthService.check({});
+ * // No need to pass headers on each call
+ * const { httpMonitors } = await client.monitor.v1.MonitorService.listMonitors({});
  *
- * // Create a monitor (auth required)
- * const headers = { "x-openstatus-key": `Bearer ${process.env.OPENSTATUS_API_KEY}` };
- * const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor({
+ * const { monitor } = await client.monitor.v1.MonitorService.createHTTPMonitor({
  *   monitor: {
- *     name: "My Website",
- *     url: "https://example.com",
+ *     name: "My API",
+ *     url: "https://api.example.com/health",
  *     periodicity: Periodicity.PERIODICITY_1M,
+ *     regions: [Region.FLY_AMS, Region.FLY_IAD],
  *     active: true,
  *   },
- * }, { headers });
+ * });
  * ```
  */
-export const openstatus: OpenStatusClient = {
-  monitor: {
-    v1: {
-      MonitorService: createClient(MonitorService, transport),
+export function createOpenStatusClient(
+  options?: OpenStatusClientOptions,
+): OpenStatusClient {
+  const transport = createTransport(options);
+
+  return {
+    monitor: {
+      v1: {
+        MonitorService: createClient(MonitorService, transport),
+      },
     },
-  },
-  health: {
-    v1: {
-      HealthService: createClient(HealthService, transport),
+    health: {
+      v1: {
+        HealthService: createClient(HealthService, transport),
+      },
     },
-  },
-  statusReport: {
-    v1: {
-      StatusReportService: createClient(StatusReportService, transport),
+    statusReport: {
+      v1: {
+        StatusReportService: createClient(StatusReportService, transport),
+      },
     },
-  },
-  statusPage: {
-    v1: {
-      StatusPageService: createClient(StatusPageService, transport),
+    statusPage: {
+      v1: {
+        StatusPageService: createClient(StatusPageService, transport),
+      },
     },
-  },
-  maintenance: {
-    v1: {
-      MaintenanceService: createClient(MaintenanceService, transport),
+    maintenance: {
+      v1: {
+        MaintenanceService: createClient(MaintenanceService, transport),
+      },
     },
-  },
-  notification: {
-    v1: {
-      NotificationService: createClient(NotificationService, transport),
+    notification: {
+      v1: {
+        NotificationService: createClient(NotificationService, transport),
+      },
     },
-  },
-};
+  };
+}
+
+/**
+ * Default OpenStatus SDK client (without pre-configured authentication).
+ *
+ * For authenticated requests, either:
+ * 1. Use `createOpenStatusClient({ apiKey })` to create a pre-configured client (recommended)
+ * 2. Pass headers manually on each call
+ *
+ * @example Using createOpenStatusClient (recommended)
+ * ```typescript
+ * import { createOpenStatusClient, Periodicity } from "@openstatus/sdk-node";
+ *
+ * const client = createOpenStatusClient({ apiKey: process.env.OPENSTATUS_API_KEY });
+ * const { monitor } = await client.monitor.v1.MonitorService.createHTTPMonitor({
+ *   monitor: { name: "My Website", url: "https://example.com", periodicity: Periodicity.PERIODICITY_1M, active: true },
+ * });
+ * ```
+ *
+ * @example Using default client with manual headers
+ * ```typescript
+ * import { openstatus, Periodicity } from "@openstatus/sdk-node";
+ *
+ * const headers = { "x-openstatus-key": `Bearer ${process.env.OPENSTATUS_API_KEY}` };
+ * const { monitor } = await openstatus.monitor.v1.MonitorService.createHTTPMonitor({
+ *   monitor: { name: "My Website", url: "https://example.com", periodicity: Periodicity.PERIODICITY_1M, active: true },
+ * }, { headers });
+ * ```
+ */
+export const openstatus: OpenStatusClient = createOpenStatusClient();