@prampta/sdk 0.3.1 → 0.4.0

package/dist/index.d.mts

@@ -0,0 +1,316 @@
+/**
+ * PRAMPTA SDK for TypeScript / Node.js
+ *
+ * Pre-generation authorization for AI content.
+ * Verifies operator Ed25519 signatures on decisions — not a blind HTTP wrapper.
+ *
+ * @example Basic verification
+ * ```ts
+ * import { Prampta } from "@prampta/sdk";
+ *
+ * const pg = new Prampta({
+ *   baseUrl: "https://api2.prampta.com",
+ *   providerId: "my-ai-service",
+ *   licenseeId: "acme-corp",
+ *   token: "pair-token",
+ * });
+ *
+ * // Throws if denied — fail-closed by default
+ * await pg.assertAllowed("leonardo-da-vinci", {
+ *   prompt: "Da Vinci in a documentary",
+ *   modality: "image",
+ *   model: "gpt-image-1",
+ * });
+ * ```
+ */
+interface PramptaConfig {
+    /** The PRAMPTA registry URL. Falls back to PRAMPTA_BASE_URL env var. */
+    baseUrl?: string;
+    /** Your provider ID. Falls back to PRAMPTA_PROVIDER_ID env var. */
+    providerId?: string;
+    /** The licensee ID. Falls back to PRAMPTA_LICENSEE_ID env var. */
+    licenseeId?: string;
+    /** The pair authentication token. Falls back to PRAMPTA_TOKEN env var. */
+    token?: string;
+    /** Request timeout in milliseconds (default 3000). */
+    timeoutMs?: number;
+    /**
+     * Max retry attempts for transient failures (network errors, timeouts,
+     * HTTP 429, and 5xx). Default 2 (so up to 3 total attempts). Set 0 to disable.
+     * Retries use exponential backoff. Non-transient errors (4xx other than 429,
+     * refusals, signature/schema errors) are never retried.
+     */
+    maxRetries?: number;
+    /** Base backoff in ms between retries; doubles each attempt. Default 200. */
+    retryBackoffMs?: number;
+    /** If true (default), deny on backend errors/timeouts. */
+    failClosed?: boolean;
+    /**
+     * Pinned operator public key(s), hex — the trust anchor for signature
+     * verification. Obtain out of band (PRAMPTA docs), not from the API that
+     * serves decisions. Pass one, or several (comma/space separated) to pin the
+     * current + next key and rotate with zero downtime. Falls back to
+     * PRAMPTA_OPERATOR_PUBLIC_KEY. If omitted, verification runs in
+     * trust-on-first-use mode (a warning is emitted) — do not do this in prod.
+     */
+    operatorPublicKeyHex?: string;
+    /**
+     * Monitor mode: when false, refusals do NOT block generation — the SDK still
+     * verifies and records a signed decision, but assertAllowed / withAuthorization
+     * proceed instead of throwing. Use for a pilot rollout. Default true.
+     */
+    enforce?: boolean;
+    /**
+     * If true (default), verify operator signature on every decision.
+     * Set to false ONLY for local development — never in production.
+     */
+    verifyDecisionSignature?: boolean;
+}
+interface VerifyRequest {
+    /** Subject to verify authorization for. */
+    subjectId: string;
+    /** Raw prompt text — will be hashed, never sent to PRAMPTA. */
+    prompt?: string;
+    /** Pre-computed SHA-256 hash. Use instead of prompt if you've already hashed. */
+    promptHash?: string;
+    /** Generation modality: "image", "video", "audio", "text", "3d". */
+    modality?: string;
+    /** The AI model being used. */
+    model?: string;
+    /** Intended use metadata. */
+    intendedUse?: {
+        channel?: string;
+        productName?: string;
+        projectName?: string;
+        categories?: string[];
+        territory?: string;
+    };
+}
+/** Options for the flat `pg.verify(subjectId, options)` convenience call. */
+interface VerifyOptions extends Omit<VerifyRequest, "subjectId"> {
+    categories?: string[];
+    channel?: string;
+    productName?: string;
+    projectName?: string;
+    territory?: string;
+}
+interface SignedDecision {
+    schemaVersion: string;
+    decisionId: string;
+    allowed: boolean;
+    reason: string | null;
+    subjectId: string;
+    licenseeId: string;
+    providerId: string;
+    licenseId: string | null;
+    promptHash: string;
+    model: string;
+    modality: string;
+    intendedUse: Record<string, unknown>;
+    obligations: Record<string, unknown>;
+    rulesText: string;
+    rulesTextHash: string;
+    watermarkPayload: string | null;
+    isHardRefusal: boolean;
+    issuedAt: number;
+    expiresAt: number;
+    operatorKeyId: string;
+    operatorSignature: string;
+    /** Strongest authority backing the subject: self | agency_asserted |
+     * consented | verified. "self" is only the registrant's own claim. */
+    subjectAuthority: string;
+    denied: boolean;
+}
+interface SubjectInfo {
+    subjectId: string;
+    status: string;
+    visibility: string;
+    rulesText: string;
+    aliases: string[];
+    publicKeyHex?: string;
+    publicKeyFingerprint?: string;
+    registeredAt: string;
+}
+interface LicenseRequestInput {
+    subjectId: string;
+    useCase: "commercial" | "editorial" | "personal" | "educational" | "research";
+    purpose?: string;
+    durationDays?: number;
+    message?: string;
+}
+interface LicenseRequestResult {
+    requestId: string;
+    status: string;
+}
+interface OutputMetadata {
+    prampta_decision_id: string;
+    prampta_license_id: string | null;
+    prampta_watermark: string | null;
+    prampta_obligations: Record<string, unknown>;
+    prampta_issued_at: number;
+}
+declare class PramptaError extends Error {
+    constructor(message: string);
+}
+declare class PramptaNetworkError extends PramptaError {
+    readonly cause_: unknown;
+    constructor(cause_: unknown);
+}
+declare class PramptaTimeoutError extends PramptaError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+declare class PramptaApiError extends PramptaError {
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+declare class PramptaSchemaError extends PramptaError {
+    constructor(message: string);
+}
+/** Operator signature verification failed — decision cannot be trusted. */
+declare class PramptaSignatureError extends PramptaError {
+    constructor(message: string);
+}
+declare class PramptaRefusalError extends PramptaError {
+    readonly decision: SignedDecision;
+    constructor(decision: SignedDecision);
+    get reason(): string;
+    get isHardRefusal(): boolean;
+    get decisionId(): string;
+    get licenseId(): string | null;
+}
+declare class PramptaFailClosedError extends PramptaError {
+    readonly cause_: unknown;
+    constructor(cause_: unknown);
+}
+declare const REFUSAL_DESCRIPTIONS: Record<string, string>;
+declare const HARD_REFUSAL_CODES: Set<string>;
+declare const SOFT_REFUSAL_CODES: Set<string>;
+/** SHA-256 of a prompt — what a decision gets bound to. Standalone twin of
+ * `Prampta.hashPrompt` so it can be imported directly. */
+declare function hashPrompt(prompt: string): Promise<string>;
+/**
+ * Canonical JSON — deterministic serialization matching Python's
+ * `json.dumps(obj, sort_keys=True, separators=(",",":"), ensure_ascii=False)`.
+ * Required for signature verification across languages.
+ *
+ * Exported so external verifiers can rebuild signed bodies and so the
+ * cross-implementation spec test vectors (spec/test-vectors) can pin it.
+ * Field names in signed protocol bodies are ASCII by construction — key
+ * sorting is identical to Python's code-point sort in that range.
+ */
+declare function canonicalJson(obj: unknown): string;
+/** One entry of the /v1/subjects/index detection index. */
+interface SubjectIndexEntry {
+    subject_id: string;
+    aliases: string[];
+    status: string;
+    visibility: string;
+}
+/**
+ * Canonical normalization for subject matching: lowercase, strip Latin
+ * diacritics, de-leet, -/_ → space, strip punctuation, collapse whitespace.
+ * Must stay behaviorally identical to the Python SDK's normalize_for_match.
+ */
+declare function normalizeForMatch(text: string): string;
+/**
+ * Detect which index entries are mentioned in `text`. Whole-word phrase
+ * containment, plus a squeezed-substring fallback (min length) that defeats
+ * letter-spacing ("a d a") and concatenation ("AdaLovelace"). Baseline layer —
+ * text only; image/voice detection is provider-side perceptual work.
+ */
+declare function matchSubjects(text: string, entries: SubjectIndexEntry[]): SubjectIndexEntry[];
+declare class Prampta {
+    private readonly baseUrl;
+    private readonly providerId;
+    private readonly licenseeId;
+    private readonly token;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly retryBackoffMs;
+    private readonly failClosed;
+    private readonly verifySignature;
+    private readonly enforce;
+    private pinnedKeys;
+    private keySetCache;
+    private keySetPromise;
+    private tofuWarned;
+    constructor(config?: PramptaConfig);
+    /** Fetch /keys and check it is self-signed by its current key. Cached. */
+    private fetchVerifiedKeySet;
+    /**
+     * Public key hex to verify a decision signed by `keyId`, enforcing the
+     * pinning trust model. A pinned match returns immediately (no network); an
+     * unpinned key id fails closed in pinned mode; unpinned/TOFU mode resolves
+     * from the self-consistent /keys set with a warning.
+     */
+    private resolveOperatorKey;
+    private subjectIndexEntries;
+    private subjectIndexFetchedAt;
+    private static readonly SUBJECT_INDEX_TTL_MS;
+    /** Fetch the raw subject detection index (/v1/subjects/index). */
+    fetchSubjectIndex(): Promise<{
+        version: number;
+        count: number;
+        subjects: SubjectIndexEntry[];
+    }>;
+    /**
+     * Detect registered subjects mentioned in `text`, using a TTL-cached
+     * copy of the subject index. Call verify()/assertAllowed() per hit.
+     */
+    matchSubjects(text: string, opts?: {
+        forceRefresh?: boolean;
+    }): Promise<SubjectIndexEntry[]>;
+    /**
+     * Verify operator Ed25519 signature over decision body.
+     * Fails closed on any error.
+     */
+    private verifyDecision;
+    /**
+     * Verify that the signed decision is bound to the correct request context.
+     * Prevents replay attacks where a valid decision for one context is used in another.
+     */
+    private verifyContextBinding;
+    verifyGeneration(request: VerifyRequest): Promise<SignedDecision>;
+    /** Flat convenience API mirroring the Python SDK: intended-use fields
+     * (categories, channel, productName, …) are accepted at the top level.
+     * Either `prompt` or `promptHash` is REQUIRED — decisions are bound to
+     * the prompt hash and the SDK refuses to request unbound ones. */
+    verify(subjectId: string, options?: VerifyOptions): Promise<SignedDecision>;
+    assertAllowed(subjectId: string, options?: Omit<VerifyRequest, "subjectId">): Promise<SignedDecision>;
+    withAuthorization<T>(request: VerifyRequest, generateFn: (decision: SignedDecision) => Promise<T>): Promise<{
+        output: T;
+        decision: SignedDecision;
+        metadata: OutputMetadata;
+    }>;
+    getSubject(subjectId: string): Promise<SubjectInfo | null>;
+    requestLicense(input: LicenseRequestInput): Promise<LicenseRequestResult>;
+    createOutputMetadata(decision: SignedDecision): OutputMetadata;
+    /**
+     * Submit a generation receipt AFTER generating — the provider's enforcement
+     * proof, bound to the decision it acted on. Records that this generation was
+     * authorized and executed under the decision's terms (verifiable post-hoc).
+     */
+    submitReceipt(decision: SignedDecision, result?: {
+        outputHash?: string;
+        model?: string;
+        watermarkEmbedded?: boolean;
+        obligationsApplied?: Record<string, unknown>;
+        generatedAt?: number;
+    }): Promise<Record<string, unknown>>;
+    health(): Promise<boolean>;
+    version(): Promise<Record<string, unknown>>;
+    static hashPrompt(prompt: string): Promise<string>;
+    private parseDecision;
+    private headers;
+    /** Transient errors worth retrying: connectivity, timeout, 429, and 5xx. */
+    private isRetryable;
+    private withRetry;
+    private post;
+    private postOnce;
+    private get;
+    private getOnce;
+}
+
+export { HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaNetworkError, PramptaRefusalError, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch };

package/dist/index.d.ts

@@ -1,3 +1,316 @@
-export { Prampta, PramptaError } from './client.js';
-export type { Prompt, PromptMetadata, CreateResult, SearchResult, CreateOptions, SearchOptions, PramptaConfig, } from './types.js';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * PRAMPTA SDK for TypeScript / Node.js
+ *
+ * Pre-generation authorization for AI content.
+ * Verifies operator Ed25519 signatures on decisions — not a blind HTTP wrapper.
+ *
+ * @example Basic verification
+ * ```ts
+ * import { Prampta } from "@prampta/sdk";
+ *
+ * const pg = new Prampta({
+ *   baseUrl: "https://api2.prampta.com",
+ *   providerId: "my-ai-service",
+ *   licenseeId: "acme-corp",
+ *   token: "pair-token",
+ * });
+ *
+ * // Throws if denied — fail-closed by default
+ * await pg.assertAllowed("leonardo-da-vinci", {
+ *   prompt: "Da Vinci in a documentary",
+ *   modality: "image",
+ *   model: "gpt-image-1",
+ * });
+ * ```
+ */
+interface PramptaConfig {
+    /** The PRAMPTA registry URL. Falls back to PRAMPTA_BASE_URL env var. */
+    baseUrl?: string;
+    /** Your provider ID. Falls back to PRAMPTA_PROVIDER_ID env var. */
+    providerId?: string;
+    /** The licensee ID. Falls back to PRAMPTA_LICENSEE_ID env var. */
+    licenseeId?: string;
+    /** The pair authentication token. Falls back to PRAMPTA_TOKEN env var. */
+    token?: string;
+    /** Request timeout in milliseconds (default 3000). */
+    timeoutMs?: number;
+    /**
+     * Max retry attempts for transient failures (network errors, timeouts,
+     * HTTP 429, and 5xx). Default 2 (so up to 3 total attempts). Set 0 to disable.
+     * Retries use exponential backoff. Non-transient errors (4xx other than 429,
+     * refusals, signature/schema errors) are never retried.
+     */
+    maxRetries?: number;
+    /** Base backoff in ms between retries; doubles each attempt. Default 200. */
+    retryBackoffMs?: number;
+    /** If true (default), deny on backend errors/timeouts. */
+    failClosed?: boolean;
+    /**
+     * Pinned operator public key(s), hex — the trust anchor for signature
+     * verification. Obtain out of band (PRAMPTA docs), not from the API that
+     * serves decisions. Pass one, or several (comma/space separated) to pin the
+     * current + next key and rotate with zero downtime. Falls back to
+     * PRAMPTA_OPERATOR_PUBLIC_KEY. If omitted, verification runs in
+     * trust-on-first-use mode (a warning is emitted) — do not do this in prod.
+     */
+    operatorPublicKeyHex?: string;
+    /**
+     * Monitor mode: when false, refusals do NOT block generation — the SDK still
+     * verifies and records a signed decision, but assertAllowed / withAuthorization
+     * proceed instead of throwing. Use for a pilot rollout. Default true.
+     */
+    enforce?: boolean;
+    /**
+     * If true (default), verify operator signature on every decision.
+     * Set to false ONLY for local development — never in production.
+     */
+    verifyDecisionSignature?: boolean;
+}
+interface VerifyRequest {
+    /** Subject to verify authorization for. */
+    subjectId: string;
+    /** Raw prompt text — will be hashed, never sent to PRAMPTA. */
+    prompt?: string;
+    /** Pre-computed SHA-256 hash. Use instead of prompt if you've already hashed. */
+    promptHash?: string;
+    /** Generation modality: "image", "video", "audio", "text", "3d". */
+    modality?: string;
+    /** The AI model being used. */
+    model?: string;
+    /** Intended use metadata. */
+    intendedUse?: {
+        channel?: string;
+        productName?: string;
+        projectName?: string;
+        categories?: string[];
+        territory?: string;
+    };
+}
+/** Options for the flat `pg.verify(subjectId, options)` convenience call. */
+interface VerifyOptions extends Omit<VerifyRequest, "subjectId"> {
+    categories?: string[];
+    channel?: string;
+    productName?: string;
+    projectName?: string;
+    territory?: string;
+}
+interface SignedDecision {
+    schemaVersion: string;
+    decisionId: string;
+    allowed: boolean;
+    reason: string | null;
+    subjectId: string;
+    licenseeId: string;
+    providerId: string;
+    licenseId: string | null;
+    promptHash: string;
+    model: string;
+    modality: string;
+    intendedUse: Record<string, unknown>;
+    obligations: Record<string, unknown>;
+    rulesText: string;
+    rulesTextHash: string;
+    watermarkPayload: string | null;
+    isHardRefusal: boolean;
+    issuedAt: number;
+    expiresAt: number;
+    operatorKeyId: string;
+    operatorSignature: string;
+    /** Strongest authority backing the subject: self | agency_asserted |
+     * consented | verified. "self" is only the registrant's own claim. */
+    subjectAuthority: string;
+    denied: boolean;
+}
+interface SubjectInfo {
+    subjectId: string;
+    status: string;
+    visibility: string;
+    rulesText: string;
+    aliases: string[];
+    publicKeyHex?: string;
+    publicKeyFingerprint?: string;
+    registeredAt: string;
+}
+interface LicenseRequestInput {
+    subjectId: string;
+    useCase: "commercial" | "editorial" | "personal" | "educational" | "research";
+    purpose?: string;
+    durationDays?: number;
+    message?: string;
+}
+interface LicenseRequestResult {
+    requestId: string;
+    status: string;
+}
+interface OutputMetadata {
+    prampta_decision_id: string;
+    prampta_license_id: string | null;
+    prampta_watermark: string | null;
+    prampta_obligations: Record<string, unknown>;
+    prampta_issued_at: number;
+}
+declare class PramptaError extends Error {
+    constructor(message: string);
+}
+declare class PramptaNetworkError extends PramptaError {
+    readonly cause_: unknown;
+    constructor(cause_: unknown);
+}
+declare class PramptaTimeoutError extends PramptaError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+declare class PramptaApiError extends PramptaError {
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+declare class PramptaSchemaError extends PramptaError {
+    constructor(message: string);
+}
+/** Operator signature verification failed — decision cannot be trusted. */
+declare class PramptaSignatureError extends PramptaError {
+    constructor(message: string);
+}
+declare class PramptaRefusalError extends PramptaError {
+    readonly decision: SignedDecision;
+    constructor(decision: SignedDecision);
+    get reason(): string;
+    get isHardRefusal(): boolean;
+    get decisionId(): string;
+    get licenseId(): string | null;
+}
+declare class PramptaFailClosedError extends PramptaError {
+    readonly cause_: unknown;
+    constructor(cause_: unknown);
+}
+declare const REFUSAL_DESCRIPTIONS: Record<string, string>;
+declare const HARD_REFUSAL_CODES: Set<string>;
+declare const SOFT_REFUSAL_CODES: Set<string>;
+/** SHA-256 of a prompt — what a decision gets bound to. Standalone twin of
+ * `Prampta.hashPrompt` so it can be imported directly. */
+declare function hashPrompt(prompt: string): Promise<string>;
+/**
+ * Canonical JSON — deterministic serialization matching Python's
+ * `json.dumps(obj, sort_keys=True, separators=(",",":"), ensure_ascii=False)`.
+ * Required for signature verification across languages.
+ *
+ * Exported so external verifiers can rebuild signed bodies and so the
+ * cross-implementation spec test vectors (spec/test-vectors) can pin it.
+ * Field names in signed protocol bodies are ASCII by construction — key
+ * sorting is identical to Python's code-point sort in that range.
+ */
+declare function canonicalJson(obj: unknown): string;
+/** One entry of the /v1/subjects/index detection index. */
+interface SubjectIndexEntry {
+    subject_id: string;
+    aliases: string[];
+    status: string;
+    visibility: string;
+}
+/**
+ * Canonical normalization for subject matching: lowercase, strip Latin
+ * diacritics, de-leet, -/_ → space, strip punctuation, collapse whitespace.
+ * Must stay behaviorally identical to the Python SDK's normalize_for_match.
+ */
+declare function normalizeForMatch(text: string): string;
+/**
+ * Detect which index entries are mentioned in `text`. Whole-word phrase
+ * containment, plus a squeezed-substring fallback (min length) that defeats
+ * letter-spacing ("a d a") and concatenation ("AdaLovelace"). Baseline layer —
+ * text only; image/voice detection is provider-side perceptual work.
+ */
+declare function matchSubjects(text: string, entries: SubjectIndexEntry[]): SubjectIndexEntry[];
+declare class Prampta {
+    private readonly baseUrl;
+    private readonly providerId;
+    private readonly licenseeId;
+    private readonly token;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly retryBackoffMs;
+    private readonly failClosed;
+    private readonly verifySignature;
+    private readonly enforce;
+    private pinnedKeys;
+    private keySetCache;
+    private keySetPromise;
+    private tofuWarned;
+    constructor(config?: PramptaConfig);
+    /** Fetch /keys and check it is self-signed by its current key. Cached. */
+    private fetchVerifiedKeySet;
+    /**
+     * Public key hex to verify a decision signed by `keyId`, enforcing the
+     * pinning trust model. A pinned match returns immediately (no network); an
+     * unpinned key id fails closed in pinned mode; unpinned/TOFU mode resolves
+     * from the self-consistent /keys set with a warning.
+     */
+    private resolveOperatorKey;
+    private subjectIndexEntries;
+    private subjectIndexFetchedAt;
+    private static readonly SUBJECT_INDEX_TTL_MS;
+    /** Fetch the raw subject detection index (/v1/subjects/index). */
+    fetchSubjectIndex(): Promise<{
+        version: number;
+        count: number;
+        subjects: SubjectIndexEntry[];
+    }>;
+    /**
+     * Detect registered subjects mentioned in `text`, using a TTL-cached
+     * copy of the subject index. Call verify()/assertAllowed() per hit.
+     */
+    matchSubjects(text: string, opts?: {
+        forceRefresh?: boolean;
+    }): Promise<SubjectIndexEntry[]>;
+    /**
+     * Verify operator Ed25519 signature over decision body.
+     * Fails closed on any error.
+     */
+    private verifyDecision;
+    /**
+     * Verify that the signed decision is bound to the correct request context.
+     * Prevents replay attacks where a valid decision for one context is used in another.
+     */
+    private verifyContextBinding;
+    verifyGeneration(request: VerifyRequest): Promise<SignedDecision>;
+    /** Flat convenience API mirroring the Python SDK: intended-use fields
+     * (categories, channel, productName, …) are accepted at the top level.
+     * Either `prompt` or `promptHash` is REQUIRED — decisions are bound to
+     * the prompt hash and the SDK refuses to request unbound ones. */
+    verify(subjectId: string, options?: VerifyOptions): Promise<SignedDecision>;
+    assertAllowed(subjectId: string, options?: Omit<VerifyRequest, "subjectId">): Promise<SignedDecision>;
+    withAuthorization<T>(request: VerifyRequest, generateFn: (decision: SignedDecision) => Promise<T>): Promise<{
+        output: T;
+        decision: SignedDecision;
+        metadata: OutputMetadata;
+    }>;
+    getSubject(subjectId: string): Promise<SubjectInfo | null>;
+    requestLicense(input: LicenseRequestInput): Promise<LicenseRequestResult>;
+    createOutputMetadata(decision: SignedDecision): OutputMetadata;
+    /**
+     * Submit a generation receipt AFTER generating — the provider's enforcement
+     * proof, bound to the decision it acted on. Records that this generation was
+     * authorized and executed under the decision's terms (verifiable post-hoc).
+     */
+    submitReceipt(decision: SignedDecision, result?: {
+        outputHash?: string;
+        model?: string;
+        watermarkEmbedded?: boolean;
+        obligationsApplied?: Record<string, unknown>;
+        generatedAt?: number;
+    }): Promise<Record<string, unknown>>;
+    health(): Promise<boolean>;
+    version(): Promise<Record<string, unknown>>;
+    static hashPrompt(prompt: string): Promise<string>;
+    private parseDecision;
+    private headers;
+    /** Transient errors worth retrying: connectivity, timeout, 429, and 5xx. */
+    private isRetryable;
+    private withRetry;
+    private post;
+    private postOnce;
+    private get;
+    private getOnce;
+}
+
+export { HARD_REFUSAL_CODES, type LicenseRequestInput, type LicenseRequestResult, type OutputMetadata, Prampta, PramptaApiError, type PramptaConfig, PramptaError, PramptaFailClosedError, PramptaNetworkError, PramptaRefusalError, PramptaSchemaError, PramptaSignatureError, PramptaTimeoutError, REFUSAL_DESCRIPTIONS, SOFT_REFUSAL_CODES, type SignedDecision, type SubjectIndexEntry, type SubjectInfo, type VerifyOptions, type VerifyRequest, canonicalJson, hashPrompt, matchSubjects, normalizeForMatch };