@hearth-auth/sdk 2.0.4 → 3.0.1

package/dist/admin.d.ts

@@ -1,22 +1,56 @@
-import type { CreateUserParams, PageResponse, Realm, UpdateUserParams, User } from "./types.js";
+import type { components } from "./generated/admin/schema.js";
+import type { CreateUserParams, PageOptions, PageResponse, Realm, UpdateUserParams, User } from "./types.js";
+type Schemas = components["schemas"];
+/** An organization, as `GET /admin/organizations/{id}` returns it. */
+export type Organization = Schemas["AdminOrganization"];
+/** Body of `POST /admin/organizations`. */
+export type CreateOrganizationParams = Schemas["AdminCreateOrganizationRequest"];
+/** Body of `PATCH /admin/organizations/{id}`; absent fields are unchanged. */
+export type UpdateOrganizationParams = Schemas["AdminUpdateOrganizationRequest"];
+/** An OAuth 2.0 client, as the `/admin/applications` routes return it. */
+export type AdminApplication = Schemas["v1OAuthClient"];
+/** Body of `POST /admin/applications`. */
+export type CreateApplicationParams = Schemas["v1RegisterClientRequest"];
+/** Body of `PATCH /admin/applications/{client_id}`; absent fields are unchanged. */
+export type UpdateApplicationParams = Schemas["v1UpdateClientRequest"];
+/** A role, as the `/admin/roles` routes return it. */
+export type AdminRole = Schemas["AdminRole"];
+/** Body of `POST /admin/roles`. */
+export type CreateRoleParams = Schemas["AdminCreateRoleRequest"];
+/** Body of `PATCH /admin/roles/{id}`; absent fields are unchanged. */
+export type UpdateRoleParams = Schemas["AdminUpdateRoleRequest"];
+/** A group, as the `/admin/groups` routes return it. */
+export type AdminGroup = Schemas["AdminGroup"];
+/** Body of `POST /admin/groups`. */
+export type CreateGroupParams = Schemas["AdminCreateGroupRequest"];
+/** Body of `PATCH /admin/groups/{id}`; absent fields are unchanged. */
+export type UpdateGroupParams = Schemas["AdminUpdateGroupRequest"];
 /**
  * Admin API client for Hearth.
  *
  * Requires a valid admin access token. All operations go through
  * the /admin/* endpoints which enforce RBAC admin role checks.
+ *
+ * Routes and path parameters are typed by the client generated from
+ * `docs/api/openapi.json` (`src/generated/admin/`, `make sdk-admin-gen`); the
+ * generated names stay internal.
+ *
+ * Every non-2xx response throws {@link HearthError} carrying the HTTP status
+ * and the response body (parsed JSON, or the raw text when it is not JSON).
  */
 export declare class AdminClient {
-    private readonly baseUrl;
-    private readonly realmId;
-    private readonly accessToken;
+    private readonly api;
+    /**
+     * @param baseUrl - Root URL of the Hearth instance.
+     * @param realmId - Realm to administer; sent as `X-Realm-ID`.
+     * @param accessToken - Token whose subject holds the admin role in that realm.
+     * @throws {@link ConfigurationError} when any argument is empty.
+     */
     constructor(baseUrl: string, realmId: string, accessToken: string);
     /** POST /admin/users — create a user. */
     createUser(params: CreateUserParams): Promise<User>;
     /** GET /admin/users — list users with pagination. */
-    listUsers(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<PageResponse<User>>;
+    listUsers(options?: PageOptions): Promise<PageResponse<User>>;
     /** GET /admin/users/:id — get a user by ID. */
     getUser(userId: string): Promise<User>;
     /** PATCH /admin/users/:id — update a user. */
@@ -24,70 +58,71 @@ export declare class AdminClient {
     /** DELETE /admin/users/:id — delete a user. */
     deleteUser(userId: string): Promise<void>;
     /** GET /admin/realms — list realms with pagination. */
-    listRealms(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<PageResponse<Realm>>;
+    listRealms(options?: PageOptions): Promise<PageResponse<Realm>>;
     /** GET /admin/realms/:id — get a realm by ID. */
     getRealm(realmId: string): Promise<Realm>;
     /** DELETE /admin/realms/:id — delete a realm. */
     deleteRealm(realmId: string): Promise<void>;
     /** POST /admin/applications — register an OAuth 2.0 client. */
-    createClient(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createClient(params: CreateApplicationParams): Promise<AdminApplication>;
     /** GET /admin/applications/:id — get a client by ID. */
-    getClient(clientId: string): Promise<Record<string, unknown>>;
+    getClient(clientId: string): Promise<AdminApplication>;
     /** PATCH /admin/applications/:id — update a client. */
-    updateClient(clientId: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    updateClient(clientId: string, params: UpdateApplicationParams): Promise<AdminApplication>;
     /**
      * POST /admin/applications/:id/regenerate-secret — replace a confidential
      * client's secret. The response carries the new `client_secret` once; the
      * old secret stops working immediately.
      */
-    regenerateClientSecret(clientId: string): Promise<Record<string, unknown>>;
+    regenerateClientSecret(clientId: string): Promise<AdminApplication>;
     /** DELETE /admin/applications/:id — delete a client. */
     deleteClient(clientId: string): Promise<void>;
     /** GET /admin/applications — list clients with optional pagination. */
-    listClients(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<{
-        items: Record<string, unknown>[];
-        next_cursor: string | null;
-    }>;
+    listClients(options?: PageOptions): Promise<PageResponse<AdminApplication>>;
     /** POST /admin/roles — create a role. */
-    createRole(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createRole(params: CreateRoleParams): Promise<AdminRole>;
     /** GET /admin/roles/:id — get a role by ID. */
-    getRole(roleId: string): Promise<Record<string, unknown>>;
+    getRole(roleId: string): Promise<AdminRole>;
     /** PATCH /admin/roles/:id — update a role. */
-    updateRole(roleId: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    updateRole(roleId: string, params: UpdateRoleParams): Promise<AdminRole>;
     /** DELETE /admin/roles/:id — delete a role. */
     deleteRole(roleId: string): Promise<void>;
     /** GET /admin/roles — list roles with optional pagination. */
-    listRoles(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<{
-        items: Record<string, unknown>[];
-        next_cursor: string | null;
-    }>;
+    listRoles(options?: PageOptions): Promise<PageResponse<AdminRole>>;
     /** POST /admin/groups — create a group. */
-    createGroup(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createGroup(params: CreateGroupParams): Promise<AdminGroup>;
     /** GET /admin/groups/:id — get a group by ID. */
-    getGroup(groupId: string): Promise<Record<string, unknown>>;
+    getGroup(groupId: string): Promise<AdminGroup>;
     /** PATCH /admin/groups/:id — update a group. */
-    updateGroup(groupId: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    updateGroup(groupId: string, params: UpdateGroupParams): Promise<AdminGroup>;
     /** DELETE /admin/groups/:id — delete a group. */
     deleteGroup(groupId: string): Promise<void>;
     /** GET /admin/groups — list groups with optional pagination. */
-    listGroups(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<{
-        items: Record<string, unknown>[];
-        next_cursor: string | null;
-    }>;
-    private headers;
-    private get;
-    private post;
-    private request;
+    listGroups(options?: PageOptions): Promise<PageResponse<AdminGroup>>;
+    /** GET /admin/organizations — list organizations with pagination. */
+    listOrganizations(options?: PageOptions): Promise<PageResponse<Organization>>;
+    /** POST /admin/organizations — create an organization. */
+    createOrganization(params: CreateOrganizationParams): Promise<Organization>;
+    /** GET /admin/organizations/:id — get an organization by ID. */
+    getOrganization(orgId: string): Promise<Organization>;
+    /**
+     * PATCH /admin/organizations/:id — update an organization. A `slug` change
+     * is refused with 400 (the slug is immutable).
+     */
+    updateOrganization(orgId: string, params: UpdateOrganizationParams): Promise<Organization>;
+    /** DELETE /admin/organizations/:id — delete an organization. */
+    deleteOrganization(orgId: string): Promise<void>;
+    /**
+     * GET /admin/organizations/:id/members/:userId/roles — the names of the
+     * extra org roles a member holds on top of the organization's base role.
+     */
+    listMemberRoles(orgId: string, userId: string): Promise<string[]>;
+    /**
+     * POST /admin/organizations/:id/members/:userId/roles — give a member an
+     * extra org role. The user must already be a member (409 otherwise).
+     */
+    addMemberRole(orgId: string, userId: string, roleName: string): Promise<void>;
+    /** DELETE /admin/organizations/:id/members/:userId/roles/:roleName — remove an extra org role. */
+    removeMemberRole(orgId: string, userId: string, roleName: string): Promise<void>;
 }
+export {};

package/dist/admin.js

@@ -1,57 +1,68 @@
+import createClient from "openapi-fetch";
 import { HearthError } from "./client.js";
+import { ConfigurationError } from "./errors.js";
 /**
  * Admin API client for Hearth.
  *
  * Requires a valid admin access token. All operations go through
  * the /admin/* endpoints which enforce RBAC admin role checks.
+ *
+ * Routes and path parameters are typed by the client generated from
+ * `docs/api/openapi.json` (`src/generated/admin/`, `make sdk-admin-gen`); the
+ * generated names stay internal.
+ *
+ * Every non-2xx response throws {@link HearthError} carrying the HTTP status
+ * and the response body (parsed JSON, or the raw text when it is not JSON).
  */
 export class AdminClient {
-    baseUrl;
-    realmId;
-    accessToken;
+    api;
+    /**
+     * @param baseUrl - Root URL of the Hearth instance.
+     * @param realmId - Realm to administer; sent as `X-Realm-ID`.
+     * @param accessToken - Token whose subject holds the admin role in that realm.
+     * @throws {@link ConfigurationError} when any argument is empty.
+     */
     constructor(baseUrl, realmId, accessToken) {
-        this.baseUrl = baseUrl;
-        this.realmId = realmId;
-        this.accessToken = accessToken;
+        if (!baseUrl)
+            throw new ConfigurationError("AdminClient: baseUrl is required");
+        if (!realmId)
+            throw new ConfigurationError("AdminClient: realmId is required");
+        if (!accessToken)
+            throw new ConfigurationError("AdminClient: accessToken is required");
+        this.api = createClient({
+            baseUrl: baseUrl.replace(/\/$/, ""),
+            headers: { "X-Realm-ID": realmId, Authorization: `Bearer ${accessToken}` },
+            fetch: forwardToGlobalFetch,
+        });
     }
     // === Users ===
     /** POST /admin/users — create a user. */
     async createUser(params) {
-        return this.post("/admin/users", {
-            email: params.email,
-            display_name: params.displayName,
-        });
+        const user = await unwrap(this.api.POST("/admin/users", {
+            body: { email: params.email, display_name: params.displayName },
+        }));
+        return toUser(user);
     }
     /** GET /admin/users — list users with pagination. */
     async listUsers(options) {
-        const q = new URLSearchParams();
-        if (options?.limit)
-            q.set("limit", String(options.limit));
-        if (options?.cursor)
-            q.set("cursor", options.cursor);
-        return this.get(`/admin/users?${q}`);
+        const result = await unwrap(this.api.GET("/admin/users", { params: { query: page(options) } }));
+        return { items: (result.items ?? []).map(toUser), next_cursor: result.next_cursor ?? null };
     }
     /** GET /admin/users/:id — get a user by ID. */
     async getUser(userId) {
-        return this.get(`/admin/users/${userId}`);
+        return toUser(await unwrap(this.api.GET("/admin/users/{id}", { params: { path: { id: userId } } })));
     }
     /** PATCH /admin/users/:id — update a user. */
     async updateUser(userId, params) {
-        return this.request("PATCH", `/admin/users/${userId}`, {
-            email: params.email,
-            display_name: params.displayName,
-            status: params.status,
-        });
+        const user = await unwrap(this.api.PATCH("/admin/users/{id}", {
+            params: { path: { id: userId } },
+            body: { email: params.email, display_name: params.displayName, status: params.status },
+        }));
+        return toUser(user);
     }
     /** DELETE /admin/users/:id — delete a user. */
     async deleteUser(userId) {
-        const resp = await fetch(`${this.baseUrl}/admin/users/${userId}`, {
-            method: "DELETE",
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
+        await unwrap(this.api.DELETE("/admin/users/{id}", { params: { path: { id: userId } } }));
     }
     // === Realms ===
     //
@@ -62,39 +73,34 @@ export class AdminClient {
     // paths and deletion are exposed.
     /** GET /admin/realms — list realms with pagination. */
     async listRealms(options) {
-        const q = new URLSearchParams();
-        if (options?.limit)
-            q.set("limit", String(options.limit));
-        if (options?.cursor)
-            q.set("cursor", options.cursor);
-        return this.get(`/admin/realms?${q}`);
+        const result = await unwrap(this.api.GET("/admin/realms", { params: { query: page(options) } }));
+        return { items: (result.items ?? []).map(toRealm), next_cursor: result.next_cursor ?? null };
     }
     /** GET /admin/realms/:id — get a realm by ID. */
     async getRealm(realmId) {
-        return this.get(`/admin/realms/${realmId}`);
+        return toRealm(await unwrap(this.api.GET("/admin/realms/{id}", { params: { path: { id: realmId } } })));
     }
     /** DELETE /admin/realms/:id — delete a realm. */
     async deleteRealm(realmId) {
-        const resp = await fetch(`${this.baseUrl}/admin/realms/${realmId}`, {
-            method: "DELETE",
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
+        await unwrap(this.api.DELETE("/admin/realms/{id}", { params: { path: { id: realmId } } }));
     }
     // === OAuth Clients ===
     /** POST /admin/applications — register an OAuth 2.0 client. */
     async createClient(params) {
-        return this.post("/admin/applications", params);
+        return unwrap(this.api.POST("/admin/applications", { body: params }));
     }
     /** GET /admin/applications/:id — get a client by ID. */
     async getClient(clientId) {
-        return this.get(`/admin/applications/${clientId}`);
+        return unwrap(this.api.GET("/admin/applications/{client_id}", {
+            params: { path: { client_id: clientId } },
+        }));
     }
     /** PATCH /admin/applications/:id — update a client. */
     async updateClient(clientId, params) {
-        return this.request("PATCH", `/admin/applications/${clientId}`, params);
+        return unwrap(this.api.PATCH("/admin/applications/{client_id}", {
+            params: { path: { client_id: clientId } },
+            body: params,
+        }));
     }
     /**
      * POST /admin/applications/:id/regenerate-secret — replace a confidential
@@ -102,130 +108,171 @@ export class AdminClient {
      * old secret stops working immediately.
      */
     async regenerateClientSecret(clientId) {
-        return this.post(`/admin/applications/${clientId}/regenerate-secret`, {});
+        return unwrap(this.api.POST("/admin/applications/{client_id}/regenerate-secret", {
+            params: { path: { client_id: clientId } },
+        }));
     }
     /** DELETE /admin/applications/:id — delete a client. */
     async deleteClient(clientId) {
-        const resp = await fetch(`${this.baseUrl}/admin/applications/${clientId}`, {
-            method: "DELETE",
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
+        await unwrap(this.api.DELETE("/admin/applications/{client_id}", {
+            params: { path: { client_id: clientId } },
+        }));
     }
     /** GET /admin/applications — list clients with optional pagination. */
     async listClients(options) {
-        const q = new URLSearchParams();
-        if (options?.limit)
-            q.set("limit", String(options.limit));
-        if (options?.cursor)
-            q.set("cursor", options.cursor);
-        const qs = q.toString();
-        return this.get(`/admin/applications${qs ? `?${qs}` : ""}`);
+        const result = await unwrap(this.api.GET("/admin/applications", { params: { query: page(options) } }));
+        return { items: result.items ?? [], next_cursor: result.next_cursor ?? null };
     }
     // === Roles ===
     /** POST /admin/roles — create a role. */
     async createRole(params) {
-        return this.post("/admin/roles", params);
+        return unwrap(this.api.POST("/admin/roles", { body: params }));
     }
     /** GET /admin/roles/:id — get a role by ID. */
     async getRole(roleId) {
-        return this.get(`/admin/roles/${roleId}`);
+        return unwrap(this.api.GET("/admin/roles/{id}", { params: { path: { id: roleId } } }));
     }
     /** PATCH /admin/roles/:id — update a role. */
     async updateRole(roleId, params) {
-        return this.request("PATCH", `/admin/roles/${roleId}`, params);
+        return unwrap(this.api.PATCH("/admin/roles/{id}", { params: { path: { id: roleId } }, body: params }));
     }
     /** DELETE /admin/roles/:id — delete a role. */
     async deleteRole(roleId) {
-        const resp = await fetch(`${this.baseUrl}/admin/roles/${roleId}`, {
-            method: "DELETE",
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
+        await unwrap(this.api.DELETE("/admin/roles/{id}", { params: { path: { id: roleId } } }));
     }
     /** GET /admin/roles — list roles with optional pagination. */
     async listRoles(options) {
-        const q = new URLSearchParams();
-        if (options?.limit)
-            q.set("limit", String(options.limit));
-        if (options?.cursor)
-            q.set("cursor", options.cursor);
-        const qs = q.toString();
-        return this.get(`/admin/roles${qs ? `?${qs}` : ""}`);
+        const result = await unwrap(this.api.GET("/admin/roles", { params: { query: page(options) } }));
+        return { items: result.items, next_cursor: result.next_cursor ?? null };
     }
     // === Groups ===
     /** POST /admin/groups — create a group. */
     async createGroup(params) {
-        return this.post("/admin/groups", params);
+        return unwrap(this.api.POST("/admin/groups", { body: params }));
     }
     /** GET /admin/groups/:id — get a group by ID. */
     async getGroup(groupId) {
-        return this.get(`/admin/groups/${groupId}`);
+        return unwrap(this.api.GET("/admin/groups/{id}", { params: { path: { id: groupId } } }));
     }
     /** PATCH /admin/groups/:id — update a group. */
     async updateGroup(groupId, params) {
-        return this.request("PATCH", `/admin/groups/${groupId}`, params);
+        return unwrap(this.api.PATCH("/admin/groups/{id}", { params: { path: { id: groupId } }, body: params }));
     }
     /** DELETE /admin/groups/:id — delete a group. */
     async deleteGroup(groupId) {
-        const resp = await fetch(`${this.baseUrl}/admin/groups/${groupId}`, {
-            method: "DELETE",
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
+        await unwrap(this.api.DELETE("/admin/groups/{id}", { params: { path: { id: groupId } } }));
     }
     /** GET /admin/groups — list groups with optional pagination. */
     async listGroups(options) {
-        const q = new URLSearchParams();
-        if (options?.limit)
-            q.set("limit", String(options.limit));
-        if (options?.cursor)
-            q.set("cursor", options.cursor);
-        const qs = q.toString();
-        return this.get(`/admin/groups${qs ? `?${qs}` : ""}`);
-    }
-    // === Org Members — removed ===
-    //
-    // Hearth serves no organization route over HTTP: there is no /admin/orgs, no
-    // /admin/orgs/:orgId/members and no per-member route anywhere in the router,
-    // so addOrgMember, listOrgMembers and removeOrgMember every one 404'd
-    // (audit 2026-08-28 §25.19). Organization membership is administered through
-    // the admin console, not the admin API.
-    headers() {
-        return {
-            "X-Realm-ID": this.realmId,
-            Authorization: `Bearer ${this.accessToken}`,
-            "Content-Type": "application/json",
-        };
-    }
-    async get(path) {
-        const resp = await fetch(`${this.baseUrl}${path}`, {
-            headers: this.headers(),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
-        return resp.json();
-    }
-    async post(path, body) {
-        return this.request("POST", path, body);
-    }
-    async request(method, path, body) {
-        const resp = await fetch(`${this.baseUrl}${path}`, {
-            method,
-            headers: this.headers(),
-            body: JSON.stringify(body),
-        });
-        if (!resp.ok) {
-            throw new HearthError(resp.status, await resp.json());
-        }
-        return resp.json();
+        const result = await unwrap(this.api.GET("/admin/groups", { params: { query: page(options) } }));
+        return { items: result.items, next_cursor: result.next_cursor ?? null };
+    }
+    // === Organizations ===
+    /** GET /admin/organizations — list organizations with pagination. */
+    async listOrganizations(options) {
+        const result = await unwrap(this.api.GET("/admin/organizations", { params: { query: page(options) } }));
+        return { items: result.items, next_cursor: result.next_cursor ?? null };
+    }
+    /** POST /admin/organizations — create an organization. */
+    async createOrganization(params) {
+        return unwrap(this.api.POST("/admin/organizations", { body: params }));
+    }
+    /** GET /admin/organizations/:id — get an organization by ID. */
+    async getOrganization(orgId) {
+        return unwrap(this.api.GET("/admin/organizations/{id}", { params: { path: { id: orgId } } }));
+    }
+    /**
+     * PATCH /admin/organizations/:id — update an organization. A `slug` change
+     * is refused with 400 (the slug is immutable).
+     */
+    async updateOrganization(orgId, params) {
+        return unwrap(this.api.PATCH("/admin/organizations/{id}", {
+            params: { path: { id: orgId } },
+            body: params,
+        }));
+    }
+    /** DELETE /admin/organizations/:id — delete an organization. */
+    async deleteOrganization(orgId) {
+        await unwrap(this.api.DELETE("/admin/organizations/{id}", { params: { path: { id: orgId } } }));
+    }
+    /**
+     * GET /admin/organizations/:id/members/:userId/roles — the names of the
+     * extra org roles a member holds on top of the organization's base role.
+     */
+    async listMemberRoles(orgId, userId) {
+        const result = await unwrap(this.api.GET("/admin/organizations/{id}/members/{user_id}/roles", {
+            params: { path: { id: orgId, user_id: userId } },
+        }));
+        return result.items;
     }
+    /**
+     * POST /admin/organizations/:id/members/:userId/roles — give a member an
+     * extra org role. The user must already be a member (409 otherwise).
+     */
+    async addMemberRole(orgId, userId, roleName) {
+        await unwrap(this.api.POST("/admin/organizations/{id}/members/{user_id}/roles", {
+            params: { path: { id: orgId, user_id: userId } },
+            body: { role_name: roleName },
+        }));
+    }
+    /** DELETE /admin/organizations/:id/members/:userId/roles/:roleName — remove an extra org role. */
+    async removeMemberRole(orgId, userId, roleName) {
+        await unwrap(this.api.DELETE("/admin/organizations/{id}/members/{user_id}/roles/{role_name}", {
+            params: { path: { id: orgId, user_id: userId, role_name: roleName } },
+        }));
+    }
+}
+/** The `limit` and `cursor` query parameters of a list call; unset ones are left out. */
+function page(options) {
+    return { limit: options?.limit, cursor: options?.cursor };
+}
+/**
+ * A user from the proto-derived `v1User` schema. Proto3 JSON leaves out a
+ * field that holds its default value, so an absent string reads as `""`.
+ */
+function toUser(user) {
+    return {
+        id: user.id ?? "",
+        email: user.email ?? "",
+        display_name: user.display_name ?? "",
+        status: user.status ?? "USER_STATUS_UNSPECIFIED",
+        created_at: user.created_at,
+        updated_at: user.updated_at,
+    };
+}
+/** A realm from the proto-derived `v1Realm` schema (see {@link toUser}). */
+function toRealm(realm) {
+    return {
+        id: realm.id ?? "",
+        name: realm.name ?? "",
+        status: realm.status ?? "REALM_STATUS_UNSPECIFIED",
+        config: realm.config ?? null,
+        created_at: realm.created_at,
+        updated_at: realm.updated_at,
+    };
+}
+/**
+ * Resolve an openapi-fetch call to its parsed body, typed by the generated
+ * schema of the route's success response (`undefined` for an empty body, e.g.
+ * 204), or throw {@link HearthError} on any non-2xx status.
+ */
+async function unwrap(call) {
+    const { data, error, response } = await call;
+    if (!response.ok)
+        throw new HearthError(response.status, error === "" ? null : (error ?? null));
+    return data;
+}
+/**
+ * openapi-fetch calls `fetch(request)`. Forward to the global `fetch` as
+ * `(url, init)`, read at call time, so the SDK keeps one transport shape and a
+ * stubbed global `fetch` sees every admin call.
+ */
+async function forwardToGlobalFetch(request) {
+    const body = request.body === null ? undefined : await request.text();
+    return globalThis.fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body,
+    });
 }
 //# sourceMappingURL=admin.js.map