@parmanasystems/sdk-client 1.0.19

package/README.md

@@ -0,0 +1,179 @@
+# @parmanasystems/sdk-client
+
+Type-safe fetch client for the parmanasystems governance server.
+
+[![npm](https://img.shields.io/npm/v/@parmanasystems/sdk-client)](https://www.npmjs.com/package/@parmanasystems/sdk-client)
+
+---
+
+## Overview
+
+`@parmanasystems/sdk-client` is a zero-dependency TypeScript client for `@parmanasystems/server`. Types are generated directly from `openapi.json` using `openapi-typescript`, so the client types are always in sync with the server API.
+
+- **Zero runtime dependencies** — native `fetch` only
+- **Fully typed** — all request bodies, responses, and error types are inferred from the OpenAPI spec
+- **Throws on non-2xx** — errors surface as `ParmanaApiError` with the HTTP status code attached
+
+---
+
+## Installation
+
+```bash
+npm install @parmanasystems/sdk-client
+```
+
+Requires Node.js ≥ 20 (for native `fetch`) or any environment with a global `fetch` implementation.
+
+---
+
+## Quick start
+
+```ts
+import { ParmanaClient } from "@parmanasystems/sdk-client";
+
+const client = new ParmanaClient({
+  baseUrl: "http://localhost:3000",
+  // apiKey: "my-secret-key",  // include if Parmana_API_KEY is set on the server
+});
+
+// Check server health
+const health = await client.health();
+console.log(health.status);   // "ok"
+console.log(health.version);  // "1.0.0"
+
+// Execute a governance decision
+const attestation = await client.execute({
+  policy_id:      "loan-approval",
+  policy_version: "v1",
+  decision_type:  "approve",
+  signals_hash:   "abc123signals",
+});
+
+console.log(attestation.result.decision);  // "approve"
+console.log(attestation.signature);         // base64 Ed25519 signature
+
+// Independently verify the attestation
+const verification = await client.verify(attestation);
+console.log(verification.valid);                          // true
+console.log(verification.checks.signature_verified);      // true
+console.log(verification.checks.runtime_verified);        // true
+console.log(verification.checks.schema_compatible);       // true
+```
+
+---
+
+## API
+
+### `new ParmanaClient(options)`
+
+```ts
+const client = new ParmanaClient({
+  baseUrl: "https://governance.example.com",
+  apiKey:  "your-bearer-token",  // optional
+});
+```
+
+| Option | Type | Required | Description |
+|---|---|---|---|
+| `baseUrl` | `string` | Yes | Base URL of the parmanasystems server |
+| `apiKey` | `string` | No | Sent as `Authorization: Bearer <apiKey>` |
+
+---
+
+### `client.health(): Promise<HealthResponse>`
+
+```ts
+const { status, version, timestamp } = await client.health();
+```
+
+---
+
+### `client.execute(request): Promise<ExecutionAttestation>`
+
+Runs the governance execution pipeline. Returns a signed `ExecutionAttestation`.
+
+```ts
+const attestation = await client.execute({
+  policy_id:      "claims-processing",
+  policy_version: "v2",
+  decision_type:  "approve-claim",
+  signals_hash:   "sha256-of-signals-payload",
+});
+```
+
+| Field | Type | Description |
+|---|---|---|
+| `policy_id` | `string` | Policy identifier |
+| `policy_version` | `string` | Semantic version of the policy |
+| `decision_type` | `string` | Decision type to execute |
+| `signals_hash` | `string` | SHA-256 hex digest of the input signals |
+
+---
+
+### `client.verify(attestation): Promise<VerificationResult>`
+
+Independently verifies an attestation. Pass the return value from `execute()` directly.
+
+```ts
+const result = await client.verify(attestation);
+
+if (!result.valid) {
+  console.error("Attestation verification failed:", result.checks);
+}
+```
+
+---
+
+## Error handling
+
+Non-2xx responses throw `ParmanaApiError`:
+
+```ts
+import { ParmanaClient, ParmanaApiError } from "@parmanasystems/sdk-client";
+
+try {
+  await client.execute({ ... });
+} catch (err) {
+  if (err instanceof ParmanaApiError) {
+    console.error(`HTTP ${err.status}: ${err.message}`);
+  }
+}
+```
+
+`ParmanaApiError.message` is populated from the server's `{ error: string }` response body, or from the HTTP status text if parsing fails.
+
+---
+
+## Types
+
+All types are derived via indexed-access from `openapi.d.ts` (generated from `openapi.json`) and re-exported from the package index:
+
+```ts
+import type {
+  HealthResponse,
+  ExecuteRequest,
+  ExecutionResult,
+  ExecutionAttestation,
+  VerificationResult,
+  ApiErrorBody,
+  ParmanaClientOptions,
+} from "@parmanasystems/sdk-client";
+```
+
+---
+
+## Regenerating types
+
+If you modify `openapi.json`, regenerate the type definitions:
+
+```bash
+cd packages/sdk-client
+npm run generate   # runs: openapi-typescript ../../openapi.json -o src/openapi.d.ts
+npm run build
+```
+
+---
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,478 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+interface paths {
+    "/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Health check */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Server is healthy */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {string} */
+                            status: "ok";
+                            version: string;
+                            /** Format: date-time */
+                            timestamp: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/execute": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute a governance decision
+         * @description Issues an execution token, runs the deterministic governance runtime, and returns a signed ExecutionAttestation.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @description Policy identifier */
+                        policy_id: string;
+                        /** @description Semantic version of the policy */
+                        policy_version: string;
+                        /** @description Decision type to execute (e.g. approve, deny) */
+                        decision_type: string;
+                        /** @description SHA-256 hex digest of the input signals payload */
+                        signals_hash: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Signed execution attestation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            result: {
+                                /** Format: uuid */
+                                execution_id: string;
+                                policy_id: string;
+                                policy_version: string;
+                                schema_version: string;
+                                runtime_version: string;
+                                runtime_hash: string;
+                                decision: string;
+                                signals_hash: string;
+                                /** Format: date-time */
+                                executed_at: string;
+                            };
+                            /** @description Base64 Ed25519 signature over the result */
+                            signature: string;
+                        };
+                    };
+                };
+                /** @description Missing or invalid request fields */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Execution failed (policy not found, token expired, replay detected) */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Verify an execution attestation
+         * @description Checks the cryptographic signature, runtime hash, and schema version of an attestation produced by POST /execute.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            /** @description An ExecutionAttestation as returned by POST /execute */
+            requestBody: {
+                content: {
+                    "application/json": {
+                        result: {
+                            /** Format: uuid */
+                            execution_id: string;
+                            policy_id: string;
+                            policy_version: string;
+                            schema_version: string;
+                            runtime_version: string;
+                            runtime_hash: string;
+                            decision: string;
+                            signals_hash: string;
+                            /** Format: date-time */
+                            executed_at: string;
+                        };
+                        /** @description Base64 Ed25519 signature over the result */
+                        signature: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Verification result with per-check breakdown */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            valid: boolean;
+                            checks: {
+                                signature_verified: boolean;
+                                runtime_verified: boolean;
+                                schema_compatible: boolean;
+                            };
+                        };
+                    };
+                };
+                /** @description Malformed attestation body */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Verification threw an unexpected error */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/manifest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Runtime bundle manifest
+         * @description Returns the signed bundle manifest for the active governance runtime.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Not yet implemented */
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {string} */
+                            error: "Not implemented";
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runtime/capabilities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Runtime capability declarations
+         * @description Lists the capabilities supported by this runtime instance.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Not yet implemented */
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {string} */
+                            error: "Not implemented";
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/evaluate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Evaluate a policy without executing
+         * @description Dry-run policy evaluation — computes a decision without issuing an attestation or consuming a replay slot.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": Record<string, never>;
+                };
+            };
+            responses: {
+                /** @description Not yet implemented */
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {string} */
+                            error: "Not implemented";
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/simulate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Simulate a governance decision dry-run
+         * @description Runs the full execution pipeline in simulation mode — no side effects, no attestation produced.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": Record<string, never>;
+                };
+            };
+            responses: {
+                /** @description Not yet implemented */
+                501: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @enum {string} */
+                            error: "Not implemented";
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+
+/** Response body for GET /health */
+type HealthResponse = paths["/health"]["get"]["responses"][200]["content"]["application/json"];
+/** Request body for POST /execute */
+type ExecuteRequest = paths["/execute"]["post"]["requestBody"]["content"]["application/json"];
+/** The inner result record inside an ExecutionAttestation */
+type ExecutionResult = paths["/execute"]["post"]["responses"][200]["content"]["application/json"]["result"];
+/** Response body for POST /execute — pass this directly to verify() */
+type ExecutionAttestation = paths["/execute"]["post"]["responses"][200]["content"]["application/json"];
+/** Response body for POST /verify */
+type VerificationResult = paths["/verify"]["post"]["responses"][200]["content"]["application/json"];
+/** Error body returned on 4xx / 5xx responses */
+type ApiErrorBody = paths["/execute"]["post"]["responses"][400]["content"]["application/json"];
+
+/** Construction options for {@link ParmanaClient}. */
+interface ParmanaClientOptions {
+    /** Base URL of the parmanasystems server, e.g. `"http://localhost:3000"`. Trailing slashes are stripped. */
+    baseUrl: string;
+    /** Bearer token for API authentication — required when the server has `Parmana_API_KEY` set. */
+    apiKey?: string;
+}
+/**
+ * Thrown by {@link ParmanaClient} whenever the server returns a non-2xx HTTP status.
+ * The `status` property holds the HTTP status code; `message` contains the
+ * server's `error` field (or `statusText` as a fallback).
+ */
+declare class ParmanaApiError extends Error {
+    /** HTTP status code returned by the server. */
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * Type-safe HTTP client for the parmanasystems governance REST API.
+ *
+ * All request and response types are derived directly from the generated
+ * `openapi.d.ts` spec, so they stay in sync with the server automatically.
+ *
+ * @example
+ * ```ts
+ * const client = new ParmanaClient({ baseUrl: "http://localhost:3000", apiKey: "secret" });
+ *
+ * const attestation = await client.execute({
+ *   policy_id: "access-control",
+ *   policy_version: "v1",
+ *   decision_type: "approve",
+ *   signals_hash: "abc123...",
+ * });
+ *
+ * const result = await client.verify(attestation);
+ * console.log(result.valid); // true
+ * ```
+ */
+declare class ParmanaClient {
+    private readonly baseUrl;
+    private readonly defaultHeaders;
+    /** @param options - Client configuration including the server URL and optional API key. */
+    constructor(options: ParmanaClientOptions);
+    private request;
+    /** GET /health — returns runtime status and version. */
+    health(): Promise<HealthResponse>;
+    /**
+     * POST /execute — runs the deterministic governance runtime and returns
+     * a signed ExecutionAttestation. The returned value can be passed
+     * directly to verify().
+     */
+    execute(request: ExecuteRequest): Promise<ExecutionAttestation>;
+    /**
+     * POST /verify — independently verifies an ExecutionAttestation.
+     * Pass the object returned by execute() straight into this method.
+     */
+    verify(attestation: ExecutionAttestation): Promise<VerificationResult>;
+}
+
+export { type ApiErrorBody, type ExecuteRequest, type ExecutionAttestation, type ExecutionResult, type HealthResponse, ParmanaApiError, ParmanaClient, type ParmanaClientOptions, type VerificationResult };

package/dist/index.js

@@ -0,0 +1,68 @@
+// src/client.ts
+var ParmanaApiError = class extends Error {
+  /** HTTP status code returned by the server. */
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "ParmanaApiError";
+    this.status = status;
+  }
+};
+var ParmanaClient = class {
+  baseUrl;
+  defaultHeaders;
+  /** @param options - Client configuration including the server URL and optional API key. */
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {}
+    };
+  }
+  async request(path, init) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        ...this.defaultHeaders,
+        ...init?.headers ?? {}
+      }
+    });
+    const body = await res.json();
+    if (!res.ok) {
+      const message = body !== null && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : res.statusText;
+      throw new ParmanaApiError(res.status, message);
+    }
+    return body;
+  }
+  /** GET /health — returns runtime status and version. */
+  async health() {
+    return this.request("/health");
+  }
+  /**
+   * POST /execute — runs the deterministic governance runtime and returns
+   * a signed ExecutionAttestation. The returned value can be passed
+   * directly to verify().
+   */
+  async execute(request) {
+    return this.request("/execute", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * POST /verify — independently verifies an ExecutionAttestation.
+   * Pass the object returned by execute() straight into this method.
+   */
+  async verify(attestation) {
+    return this.request("/verify", {
+      method: "POST",
+      body: JSON.stringify(attestation)
+    });
+  }
+};
+export {
+  ParmanaApiError,
+  ParmanaClient
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import type {\n  HealthResponse,\n  ExecuteRequest,\n  ExecutionAttestation,\n  VerificationResult,\n} from \"./types.js\";\n\n/** Construction options for {@link ParmanaClient}. */\nexport interface ParmanaClientOptions {\n  /** Base URL of the parmanasystems server, e.g. `\"http://localhost:3000\"`. Trailing slashes are stripped. */\n  baseUrl: string;\n  /** Bearer token for API authentication — required when the server has `Parmana_API_KEY` set. */\n  apiKey?: string;\n}\n\n/**\n * Thrown by {@link ParmanaClient} whenever the server returns a non-2xx HTTP status.\n * The `status` property holds the HTTP status code; `message` contains the\n * server's `error` field (or `statusText` as a fallback).\n */\nexport class ParmanaApiError extends Error {\n  /** HTTP status code returned by the server. */\n  readonly status: number;\n\n  constructor(status: number, message: string) {\n    super(message);\n    this.name = \"ParmanaApiError\";\n    this.status = status;\n  }\n}\n\n/**\n * Type-safe HTTP client for the parmanasystems governance REST API.\n *\n * All request and response types are derived directly from the generated\n * `openapi.d.ts` spec, so they stay in sync with the server automatically.\n *\n * @example\n * ```ts\n * const client = new ParmanaClient({ baseUrl: \"http://localhost:3000\", apiKey: \"secret\" });\n *\n * const attestation = await client.execute({\n *   policy_id: \"access-control\",\n *   policy_version: \"v1\",\n *   decision_type: \"approve\",\n *   signals_hash: \"abc123...\",\n * });\n *\n * const result = await client.verify(attestation);\n * console.log(result.valid); // true\n * ```\n */\nexport class ParmanaClient {\n  private readonly baseUrl: string;\n  private readonly defaultHeaders: Record<string, string>;\n\n  /** @param options - Client configuration including the server URL and optional API key. */\n  constructor(options: ParmanaClientOptions) {\n    this.baseUrl = options.baseUrl.replace(/\\/$/, \"\");\n    this.defaultHeaders = {\n      \"Content-Type\": \"application/json\",\n      \"Accept\": \"application/json\",\n      ...(options.apiKey\n        ? { Authorization: `Bearer ${options.apiKey}` }\n        : {}),\n    };\n  }\n\n  private async request<TRes>(\n    path: string,\n    init?: RequestInit\n  ): Promise<TRes> {\n    const res = await fetch(`${this.baseUrl}${path}`, {\n      ...init,\n      headers: {\n        ...this.defaultHeaders,\n        ...(init?.headers ?? {}),\n      },\n    });\n\n    const body: unknown = await res.json();\n\n    if (!res.ok) {\n      const message =\n        body !== null &&\n        typeof body === \"object\" &&\n        \"error\" in body &&\n        typeof (body as { error: unknown }).error === \"string\"\n          ? (body as { error: string }).error\n          : res.statusText;\n      throw new ParmanaApiError(res.status, message);\n    }\n\n    return body as TRes;\n  }\n\n  /** GET /health — returns runtime status and version. */\n  async health(): Promise<HealthResponse> {\n    return this.request<HealthResponse>(\"/health\");\n  }\n\n  /**\n   * POST /execute — runs the deterministic governance runtime and returns\n   * a signed ExecutionAttestation. The returned value can be passed\n   * directly to verify().\n   */\n  async execute(request: ExecuteRequest): Promise<ExecutionAttestation> {\n    return this.request<ExecutionAttestation>(\"/execute\", {\n      method: \"POST\",\n      body: JSON.stringify(request),\n    });\n  }\n\n  /**\n   * POST /verify — independently verifies an ExecutionAttestation.\n   * Pass the object returned by execute() straight into this method.\n   */\n  async verify(attestation: ExecutionAttestation): Promise<VerificationResult> {\n    return this.request<VerificationResult>(\"/verify\", {\n      method: \"POST\",\n      body: JSON.stringify(attestation),\n    });\n  }\n}\n"],"mappings":";AAoBO,IAAM,kBAAN,cAA8B,MAAM;AAAA;AAAA,EAEhC;AAAA,EAET,YAAY,QAAgB,SAAiB;AAC3C,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,SAAS;AAAA,EAChB;AACF;AAuBO,IAAM,gBAAN,MAAoB;AAAA,EACR;AAAA,EACA;AAAA;AAAA,EAGjB,YAAY,SAA+B;AACzC,SAAK,UAAU,QAAQ,QAAQ,QAAQ,OAAO,EAAE;AAChD,SAAK,iBAAiB;AAAA,MACpB,gBAAgB;AAAA,MAChB,UAAU;AAAA,MACV,GAAI,QAAQ,SACR,EAAE,eAAe,UAAU,QAAQ,MAAM,GAAG,IAC5C,CAAC;AAAA,IACP;AAAA,EACF;AAAA,EAEA,MAAc,QACZ,MACA,MACe;AACf,UAAM,MAAM,MAAM,MAAM,GAAG,KAAK,OAAO,GAAG,IAAI,IAAI;AAAA,MAChD,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAG,KAAK;AAAA,QACR,GAAI,MAAM,WAAW,CAAC;AAAA,MACxB;AAAA,IACF,CAAC;AAED,UAAM,OAAgB,MAAM,IAAI,KAAK;AAErC,QAAI,CAAC,IAAI,IAAI;AACX,YAAM,UACJ,SAAS,QACT,OAAO,SAAS,YAChB,WAAW,QACX,OAAQ,KAA4B,UAAU,WACzC,KAA2B,QAC5B,IAAI;AACV,YAAM,IAAI,gBAAgB,IAAI,QAAQ,OAAO;AAAA,IAC/C;AAEA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAM,SAAkC;AACtC,WAAO,KAAK,QAAwB,SAAS;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,QAAQ,SAAwD;AACpE,WAAO,KAAK,QAA8B,YAAY;AAAA,MACpD,QAAQ;AAAA,MACR,MAAM,KAAK,UAAU,OAAO;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,OAAO,aAAgE;AAC3E,WAAO,KAAK,QAA4B,WAAW;AAAA,MACjD,QAAQ;AAAA,MACR,MAAM,KAAK,UAAU,WAAW;AAAA,IAClC,CAAC;AAAA,EACH;AACF;","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@parmanasystems/sdk-client",
+  "version": "1.0.19",
+  "private": false,
+  "type": "module",
+  "description": "Type-safe SDK client for the parmanasystems Runtime API.",
+  "scripts": {
+    "build": "tsup",
+    "generate": "openapi-typescript ../../openapi.json -o src/openapi.d.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "devDependencies": {
+    "openapi-typescript": "^7.13.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pavancharak/parmanasystems-core.git"
+  },
+  "homepage": "https://github.com/pavancharak/parmanasystems-core",
+  "bugs": {
+    "url": "https://github.com/pavancharak/parmanasystems-core/issues"
+  },
+  "keywords": [
+    "sdk",
+    "client",
+    "governance",
+    "attestation",
+    "deterministic"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}