roe-typescript 1.1.0 → 1.1.2

package/dist/api/knowledge_base.d.ts

@@ -0,0 +1,67 @@
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type CreateKnowledgeBase = components["schemas"]["CreateKnowledgeBase"];
+type Draft = components["schemas"]["Draft"];
+type KnowledgeBase = components["schemas"]["KnowledgeBase"];
+type PaginatedKnowledgeBaseList = components["schemas"]["PaginatedKnowledgeBaseList"];
+export declare class KnowledgeBaseAPI {
+    readonly config: RoeConfig;
+    readonly raw: RoeRawClient;
+    /** API for managing Knowledge Base lenses and drafts. */
+    constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List all knowledge bases for the organisation. */
+    list(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedKnowledgeBaseList>;
+    /** Create a new knowledge base draft (async generation). */
+    create(params: {
+        company: string;
+        brief: string;
+        name?: string;
+        productName?: string;
+        websiteUrl?: string;
+    }): Promise<CreateKnowledgeBase>;
+    /** Retrieve a single knowledge base record. */
+    retrieve(knowledgeBaseId: string): Promise<KnowledgeBase>;
+    /** Delete a knowledge base and its associated Atlas draft or lens. */
+    delete(knowledgeBaseId: string): Promise<void>;
+    /** Unlink a knowledge base locally, preserving the Atlas lens. */
+    unlink(knowledgeBaseId: string): Promise<void>;
+    /** Poll the Atlas draft status until ready or error. */
+    pollDraft(knowledgeBaseId: string): Promise<Draft>;
+    /** Patch the draft's typology/tactic selection. */
+    patchSelection(knowledgeBaseId: string, selection: {
+        refs: Record<string, unknown>[];
+        suggestedName?: string;
+    }): Promise<Draft>;
+    /** Kick off an async regeneration round with optional feedback. */
+    regenerate(knowledgeBaseId: string, params?: {
+        feedback?: string;
+    }): Promise<Draft>;
+    /** Approve or decline a pending regeneration proposal. */
+    resolve(knowledgeBaseId: string, params?: {
+        refs?: Record<string, unknown>[];
+        suggestedName?: string;
+        acceptSummary?: boolean;
+        discard?: boolean;
+    }): Promise<Draft>;
+    /** Commit the draft into a permanent Atlas lens. */
+    finalize(knowledgeBaseId: string, params?: {
+        name?: string;
+        mcpEnabled?: boolean;
+        public?: boolean;
+    }): Promise<KnowledgeBase>;
+    /** Sync the lens snapshot from Atlas (best-effort). */
+    sync(knowledgeBaseId: string): Promise<KnowledgeBase>;
+    /** Fetch the names-only typology and tactic catalog. */
+    catalog(): Promise<unknown>;
+    /** Fetch and optionally sync a lens by its Atlas ID. */
+    lensByAtlasId(atlasLensId: string): Promise<unknown>;
+    /** Import a finalized Atlas lens into roe-main by its atlas_lens_id. */
+    importLens(atlasLensId: string): Promise<KnowledgeBase>;
+}
+export {};

package/dist/api/knowledge_base.js

@@ -0,0 +1,202 @@
+import { BadRequestError } from "../exceptions.js";
+import { isUuidString } from "../utils/fileDetection.js";
+function validateUuid(value, fieldName) {
+    if (!isUuidString(value)) {
+        throw new BadRequestError(`Invalid ${fieldName}: "${value}" is not a valid UUID`, 400);
+    }
+}
+export class KnowledgeBaseAPI {
+    /** API for managing Knowledge Base lenses and drafts. */
+    constructor(config, raw) {
+        this.config = config;
+        this.raw = raw;
+    }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List all knowledge bases for the organisation. */
+    async list(params) {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/", {
+            params: {
+                query: {
+                    organization_id: this.organizationId,
+                    ...(params?.page !== undefined ? { page: params.page } : {}),
+                    ...(params?.pageSize !== undefined
+                        ? { page_size: params.pageSize }
+                        : {}),
+                },
+            },
+        });
+        return data;
+    }
+    /** Create a new knowledge base draft (async generation). */
+    async create(params) {
+        const body = {
+            company: params.company,
+            brief: params.brief,
+            ...(params.name !== undefined ? { name: params.name } : {}),
+            ...(params.productName !== undefined
+                ? { product_name: params.productName }
+                : {}),
+            ...(params.websiteUrl !== undefined
+                ? { website_url: params.websiteUrl }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/", {
+            params: { query: { organization_id: this.organizationId } },
+            body,
+        });
+        return data;
+    }
+    /** Retrieve a single knowledge base record. */
+    async retrieve(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/{id}/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Delete a knowledge base and its associated Atlas draft or lens. */
+    async delete(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        await this.rawClient.DELETE("/v1/knowledge-base/{id}/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    /** Unlink a knowledge base locally, preserving the Atlas lens. */
+    async unlink(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        await this.rawClient.DELETE("/v1/knowledge-base/{id}/unlink/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    /** Poll the Atlas draft status until ready or error. */
+    async pollDraft(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/{id}/draft/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Patch the draft's typology/tactic selection. */
+    async patchSelection(knowledgeBaseId, selection) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            refs: selection.refs,
+            ...(selection.suggestedName !== undefined
+                ? { suggested_name: selection.suggestedName }
+                : {}),
+        };
+        const { data } = await this.rawClient.PATCH("/v1/knowledge-base/{id}/selection/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Kick off an async regeneration round with optional feedback. */
+    async regenerate(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            ...(params?.feedback !== undefined ? { feedback: params.feedback } : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/regenerate/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Approve or decline a pending regeneration proposal. */
+    async resolve(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            accept_summary: params?.acceptSummary ?? false,
+            discard: params?.discard ?? false,
+            ...(params?.refs !== undefined ? { refs: params.refs } : {}),
+            ...(params?.suggestedName !== undefined
+                ? { suggested_name: params.suggestedName }
+                : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/resolve/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Commit the draft into a permanent Atlas lens. */
+    async finalize(knowledgeBaseId, params) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const body = {
+            mcp_enabled: params?.mcpEnabled ?? true,
+            public: params?.public ?? true,
+            ...(params?.name !== undefined ? { name: params.name } : {}),
+        };
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/finalize/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Sync the lens snapshot from Atlas (best-effort). */
+    async sync(knowledgeBaseId) {
+        validateUuid(knowledgeBaseId, "knowledgeBaseId");
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/{id}/sync/", {
+            params: {
+                path: { id: knowledgeBaseId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Fetch the names-only typology and tactic catalog. */
+    async catalog() {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/catalog/", {
+            params: { query: { organization_id: this.organizationId } },
+        });
+        return data;
+    }
+    /** Fetch and optionally sync a lens by its Atlas ID. */
+    async lensByAtlasId(atlasLensId) {
+        const { data } = await this.rawClient.GET("/v1/knowledge-base/lens/{atlas_lens_id}/", {
+            params: {
+                path: { atlas_lens_id: atlasLensId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
+    }
+    /** Import a finalized Atlas lens into roe-main by its atlas_lens_id. */
+    async importLens(atlasLensId) {
+        const { data } = await this.rawClient.POST("/v1/knowledge-base/import-lens/", {
+            params: { query: { organization_id: this.organizationId } },
+            body: { atlas_lens_id: atlasLensId },
+        });
+        return data;
+    }
+}

package/dist/api/policies.d.ts

@@ -1,18 +1,22 @@
-import { RoeConfig } from "../config.js";
+import type { RoeConfig } from "../config.js";
 import type { RoeRawClient } from "../generated/client.js";
 import type { components } from "../generated/schema.js";
-type Policy = components["schemas"]["Policy"];
 type CreatePolicy = components["schemas"]["CreatePolicy"];
-type UpdatePolicy = components["schemas"]["UpdatePolicy"];
-type PolicyVersion = components["schemas"]["PolicyVersion"];
 type PaginatedPolicyList = components["schemas"]["PaginatedPolicyList"];
+type Policy = components["schemas"]["Policy"];
+type PolicyVersion = components["schemas"]["PolicyVersion"];
+type UpdatePolicy = components["schemas"]["UpdatePolicy"];
 export declare class PolicyVersionsAPI {
     private readonly policiesApi;
+    /** API for managing the versions of a policy. */
     constructor(policiesApi: PoliciesAPI);
-    private get raw();
-    private get organizationId();
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List all versions of a policy. */
     list(policyId: string): Promise<PolicyVersion[]>;
+    /** Retrieve a single policy version. */
     retrieve(policyId: string, versionId: string): Promise<PolicyVersion>;
+    /** Create a new version of a policy. */
     create(params: {
         policyId: string;
         content: Record<string, unknown>;
@@ -23,23 +27,36 @@ export declare class PolicyVersionsAPI {
 export declare class PoliciesAPI {
     readonly config: RoeConfig;
     readonly raw: RoeRawClient;
+    /** API for managing Roe policies and their versions. */
     readonly versions: PolicyVersionsAPI;
     constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List policies in the organization (paginated). */
     list(params?: {
         page?: number;
         pageSize?: number;
     }): Promise<PaginatedPolicyList>;
+    /** Retrieve a single policy by ID. */
     retrieve(policyId: string): Promise<Policy>;
+    /** Create a new policy together with its first version. */
     create(params: {
         name: string;
         content: Record<string, unknown>;
         description?: string;
         versionName?: string;
     }): Promise<CreatePolicy>;
+    /** Update mutable fields of a policy. */
     update(policyId: string, updates: {
         name?: string;
         description?: string;
     }): Promise<UpdatePolicy>;
+    /** Replace a policy. */
+    replace(policyId: string, replacement: {
+        name: string;
+        description?: string;
+    }): Promise<UpdatePolicy>;
+    /** Delete a policy. */
     delete(policyId: string): Promise<void>;
 }
 export {};

package/dist/api/policies.js

@@ -1,38 +1,40 @@
-import { isUuidString } from "../utils/fileDetection.js";
+// Auto-generated friendly API facades for the Roe SDK.
+// Generated by scripts/generate-sdk from openapi/wrappers.yml.
+// Do not edit by hand.
 import { BadRequestError, RoeAPIException } from "../exceptions.js";
-/**
- * Validates that a value is a valid UUID string.
- * @throws BadRequestError if the value is not a valid UUID
- */
+import { isUuidString } from "../utils/fileDetection.js";
 function validateUuid(value, fieldName) {
     if (!isUuidString(value)) {
         throw new BadRequestError(`Invalid ${fieldName}: "${value}" is not a valid UUID`, 400);
     }
 }
 export class PolicyVersionsAPI {
+    /** API for managing the versions of a policy. */
     constructor(policiesApi) {
         this.policiesApi = policiesApi;
     }
-    get raw() {
+    get rawClient() {
         return this.policiesApi.raw;
     }
     get organizationId() {
         return this.policiesApi.config.organizationId;
     }
+    /** List all versions of a policy. */
     async list(policyId) {
         validateUuid(policyId, "policyId");
-        const { data } = await this.raw.GET("/v1/policies/{policy_id}/versions/", {
+        const { data } = await this.rawClient.GET("/v1/policies/{policy_id}/versions/", {
             params: {
                 path: { policy_id: policyId },
                 query: { organization_id: this.organizationId },
             },
         });
-        return data?.results ?? [];
+        return (data?.results ?? []);
     }
+    /** Retrieve a single policy version. */
     async retrieve(policyId, versionId) {
         validateUuid(policyId, "policyId");
         validateUuid(versionId, "versionId");
-        const { data } = await this.raw.GET("/v1/policies/{policy_id}/versions/{version_id}/", {
+        const { data } = await this.rawClient.GET("/v1/policies/{policy_id}/versions/{version_id}/", {
             params: {
                 path: { policy_id: policyId, version_id: versionId },
                 query: { organization_id: this.organizationId },
@@ -40,18 +42,21 @@ export class PolicyVersionsAPI {
         });
         return data;
     }
+    /** Create a new version of a policy. */
     async create(params) {
         validateUuid(params.policyId, "policyId");
-        if (params.baseVersionId !== undefined)
+        if (params.baseVersionId != null)
             validateUuid(params.baseVersionId, "baseVersionId");
         const body = {
             content: params.content,
+            ...(params.versionName !== undefined
+                ? { version_name: params.versionName }
+                : {}),
+            ...(params.baseVersionId !== undefined
+                ? { base_version_id: params.baseVersionId }
+                : {}),
         };
-        if (params.versionName !== undefined)
-            body.version_name = params.versionName;
-        if (params.baseVersionId !== undefined)
-            body.base_version_id = params.baseVersionId;
-        const { data } = await this.raw.POST("/v1/policies/{policy_id}/versions/", {
+        const { data } = await this.rawClient.POST("/v1/policies/{policy_id}/versions/", {
             params: {
                 path: { policy_id: params.policyId },
                 query: { organization_id: this.organizationId },
@@ -61,7 +66,6 @@ export class PolicyVersionsAPI {
         if (!data?.id) {
             throw new RoeAPIException(`Unexpected response from server: ${JSON.stringify(data)}`);
         }
-        // POST returns a partial CreatePolicyVersion; re-fetch to get the full version.
         return this.retrieve(params.policyId, data.id);
     }
 }
@@ -71,28 +75,39 @@ export class PoliciesAPI {
         this.raw = raw;
         this.versions = new PolicyVersionsAPI(this);
     }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List policies in the organization (paginated). */
     async list(params) {
-        const { data } = await this.raw.GET("/v1/policies/", {
+        const { data } = await this.rawClient.GET("/v1/policies/", {
             params: {
                 query: {
-                    organization_id: this.config.organizationId,
-                    page: params?.page,
-                    page_size: params?.pageSize,
+                    organization_id: this.organizationId,
+                    ...(params?.page !== undefined ? { page: params?.page } : {}),
+                    ...(params?.pageSize !== undefined
+                        ? { page_size: params?.pageSize }
+                        : {}),
                 },
             },
         });
         return data;
     }
+    /** Retrieve a single policy by ID. */
     async retrieve(policyId) {
         validateUuid(policyId, "policyId");
-        const { data } = await this.raw.GET("/v1/policies/{id}/", {
+        const { data } = await this.rawClient.GET("/v1/policies/{id}/", {
             params: {
                 path: { id: policyId },
-                query: { organization_id: this.config.organizationId },
+                query: { organization_id: this.organizationId },
             },
         });
         return data;
     }
+    /** Create a new policy together with its first version. */
     async create(params) {
         const body = {
             name: params.name,
@@ -100,34 +115,55 @@ export class PoliciesAPI {
             description: params.description ?? "",
             version_name: params.versionName ?? "version 1",
         };
-        const { data } = await this.raw.POST("/v1/policies/", {
-            params: { query: { organization_id: this.config.organizationId } },
+        const { data } = await this.rawClient.POST("/v1/policies/", {
+            params: { query: { organization_id: this.organizationId } },
             body,
         });
         return data;
     }
+    /** Update mutable fields of a policy. */
     async update(policyId, updates) {
         validateUuid(policyId, "policyId");
-        const body = {};
-        if (updates.name !== undefined)
-            body.name = updates.name;
-        if (updates.description !== undefined)
-            body.description = updates.description;
-        const { data } = await this.raw.PATCH("/v1/policies/{id}/", {
+        const body = {
+            ...(updates.name !== undefined ? { name: updates.name } : {}),
+            ...(updates.description !== undefined
+                ? { description: updates.description }
+                : {}),
+        };
+        const { data } = await this.rawClient.PATCH("/v1/policies/{id}/", {
             params: {
                 path: { id: policyId },
-                query: { organization_id: this.config.organizationId },
+                query: { organization_id: this.organizationId },
             },
             body,
         });
         return data;
     }
+    /** Replace a policy. */
+    async replace(policyId, replacement) {
+        validateUuid(policyId, "policyId");
+        const body = {
+            name: replacement.name,
+            ...(replacement.description !== undefined
+                ? { description: replacement.description }
+                : {}),
+        };
+        const { data } = await this.rawClient.PUT("/v1/policies/{id}/", {
+            params: {
+                path: { id: policyId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
+        return data;
+    }
+    /** Delete a policy. */
     async delete(policyId) {
         validateUuid(policyId, "policyId");
-        await this.raw.DELETE("/v1/policies/{id}/", {
+        await this.rawClient.DELETE("/v1/policies/{id}/", {
             params: {
                 path: { id: policyId },
-                query: { organization_id: this.config.organizationId },
+                query: { organization_id: this.organizationId },
             },
         });
     }

package/dist/api/tables.d.ts

@@ -2,6 +2,11 @@ import type { RoeConfig } from "../config.js";
 import type { RoeRawClient } from "../generated/client.js";
 import type { components } from "../generated/schema.js";
 import type { FileUpload } from "../models/file.js";
+type TableDescribeResponse = components["schemas"]["TableDescribeResponse"];
+type TableListResponse = components["schemas"]["TableListResponse"];
+type TablePreviewResponse = components["schemas"]["TablePreviewResponse"];
+type TableQueryResultResponse = components["schemas"]["TableQueryResultResponse"];
+type TableQuerySubmitResponse = components["schemas"]["TableQuerySubmitResponse"];
 type TableUploadResponse = components["schemas"]["TableUploadResponse"];
 export type TableUploadFile = string | NodeJS.ReadableStream | FileUpload;
 export type TableUploadParams = {
@@ -13,9 +18,28 @@ export type TableUploadParams = {
 export declare class TablesAPI {
     readonly config: RoeConfig;
     readonly raw: RoeRawClient;
-    /** API for uploading CSV files into Roe tables. */
+    /** API for managing Roe tables. */
     constructor(config: RoeConfig, raw: RoeRawClient);
+    protected get rawClient(): RoeRawClient;
+    protected get organizationId(): string;
+    /** List Roe tables. */
+    list(): Promise<TableListResponse>;
     /** Upload a CSV file and create a Roe table. */
     upload(params: TableUploadParams): Promise<TableUploadResponse>;
+    /** Run a read-only query against Roe tables. */
+    query(params: {
+        sql: string;
+        limit?: number;
+    }): Promise<TableQuerySubmitResponse>;
+    /** Get the result for a submitted table query. */
+    queryResult(tableQueryId: string): Promise<TableQueryResultResponse>;
+    /** Describe a Roe table. */
+    describe(tableName: string): Promise<TableDescribeResponse>;
+    /** Preview rows from a Roe table. */
+    preview(tableName: string, options?: {
+        limit?: number;
+    }): Promise<TablePreviewResponse>;
+    /** Delete a Roe table. */
+    delete(tableName: string): Promise<void>;
 }
 export {};

package/dist/api/tables.js

@@ -4,11 +4,22 @@
 import { RoeAPIException } from "../exceptions.js";
 import { postDynamicInputs } from "../utils/dynamicInputs.js";
 export class TablesAPI {
-    /** API for uploading CSV files into Roe tables. */
+    /** API for managing Roe tables. */
     constructor(config, raw) {
         this.config = config;
         this.raw = raw;
     }
+    get rawClient() {
+        return this.raw;
+    }
+    get organizationId() {
+        return this.config.organizationId;
+    }
+    /** List Roe tables. */
+    async list() {
+        const { data } = await this.rawClient.GET("/v1/tables/", {});
+        return data;
+    }
     /** Upload a CSV file and create a Roe table. */
     async upload(params) {
         const inputs = {
@@ -23,4 +34,41 @@ export class TablesAPI {
         }
         return data;
     }
+    /** Run a read-only query against Roe tables. */
+    async query(params) {
+        const body = {
+            sql: params.sql,
+            limit: params.limit ?? 1000,
+        };
+        const { data } = await this.rawClient.POST("/v1/tables/query/", { body });
+        return data;
+    }
+    /** Get the result for a submitted table query. */
+    async queryResult(tableQueryId) {
+        const { data } = await this.rawClient.GET("/v1/tables/query/{table_query_id}/result/", { params: { path: { table_query_id: tableQueryId } } });
+        return data;
+    }
+    /** Describe a Roe table. */
+    async describe(tableName) {
+        const { data } = await this.rawClient.GET("/v1/tables/{table_name}/describe/", { params: { path: { table_name: tableName } } });
+        return data;
+    }
+    /** Preview rows from a Roe table. */
+    async preview(tableName, options) {
+        const { data } = await this.rawClient.GET("/v1/tables/{table_name}/preview/", {
+            params: {
+                path: { table_name: tableName },
+                query: {
+                    ...(options?.limit !== undefined ? { limit: options?.limit } : {}),
+                },
+            },
+        });
+        return data;
+    }
+    /** Delete a Roe table. */
+    async delete(tableName) {
+        await this.rawClient.DELETE("/v1/tables/{table_name}/", {
+            params: { path: { table_name: tableName } },
+        });
+    }
 }

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { RoeConfig } from "./config.js";
+import type { RoeConfig } from "./config.js";
 export declare class RoeAuth {
     private readonly config;
     constructor(config: RoeConfig);

package/dist/auth.js

@@ -1,6 +1,6 @@
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 // Resolve the package's own version at runtime so the User-Agent doesn't
 // silently drift across releases when the auto-release pipeline bumps
 // package.json without touching this file. Falls back to "0.0.0" if the

package/dist/client.d.ts

@@ -1,9 +1,9 @@
-import { AgentsAPI } from "./api/agents.js";
 import { type GeneratedApis } from "./api/_generated.js";
+import { AgentsAPI } from "./api/agents.js";
 import { PoliciesAPI } from "./api/policies.js";
 import { UsersAPI } from "./api/users.js";
 import { RoeAuth } from "./auth.js";
-import { RoeConfig, RoeConfigInput } from "./config.js";
+import { RoeConfig, type RoeConfigInput } from "./config.js";
 import { type RoeRawClient } from "./generated/client.js";
 export declare class RoeClient {
     readonly config: RoeConfig;