@sparkvault/sdk 1.0.0

package/dist/rng/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * RNG Module
+ *
+ * Generate cryptographically secure random numbers.
+ * Uses hybrid entropy from AWS KMS HSM + local CSPRNG.
+ */
+import { HttpClient } from '../http';
+import type { GenerateOptions, RandomResult } from './types';
+export declare class RNGModule {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Generate cryptographically secure random bytes.
+     *
+     * @example
+     * const result = await sv.rng.generate({ bytes: 32, format: 'hex' });
+     * console.log(result.value);
+     */
+    generate(options: GenerateOptions): Promise<RandomResult>;
+    /**
+     * Generate a random UUID v4.
+     *
+     * @example
+     * const uuid = await sv.rng.uuid();
+     * console.log(uuid); // 'f47ac10b-58cc-4372-a567-0e02b2c3d479'
+     */
+    uuid(): Promise<string>;
+    /**
+     * Generate a random hex string.
+     *
+     * @example
+     * const hex = await sv.rng.hex(16);
+     * console.log(hex); // '1a2b3c4d5e6f7890...'
+     */
+    hex(bytes: number): Promise<string>;
+    /**
+     * Generate a random alphanumeric string.
+     *
+     * @example
+     * const code = await sv.rng.alphanumeric(8);
+     * console.log(code); // 'A1B2C3D4'
+     */
+    alphanumeric(bytes: number): Promise<string>;
+    /**
+     * Generate a random password with special characters.
+     *
+     * @example
+     * const password = await sv.rng.password(16);
+     * console.log(password); // 'aB3$xY7!mN9@pQ2#'
+     */
+    password(bytes: number): Promise<string>;
+    private validateOptions;
+}
+export type { GenerateOptions, RandomResult, RNGFormat } from './types';

package/dist/rng/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * RNG Module Types
+ */
+export type RNGFormat = 'hex' | 'base64' | 'base64url' | 'alphanumeric' | 'alphanumeric-mixed' | 'password' | 'numeric' | 'uuid' | 'bytes';
+export interface GenerateOptions {
+    /** Number of bytes to generate (1-1024) */
+    bytes: number;
+    /** Output format (default: 'base64url') */
+    format?: RNGFormat;
+}
+export interface RandomResult {
+    /** Generated random value */
+    value: string | number[];
+    /** Number of bytes generated */
+    bytes: number;
+    /** Format used */
+    format: RNGFormat;
+    /** Reference ID for billing/audit */
+    referenceId: string;
+}
+export interface GenerateResponse {
+    random_bytes_b64: string;
+    num_bytes: number;
+    format: string;
+    reference_id: string;
+}

package/dist/sparks/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sparks Module
+ *
+ * Create and read ephemeral encrypted secrets.
+ * Sparks are destroyed after being read (burn-on-read).
+ */
+import { HttpClient } from '../http';
+import type { CreateSparkOptions, Spark, SparkPayload } from './types';
+export declare class SparksModule {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create an ephemeral encrypted secret.
+     *
+     * @example
+     * const spark = await sv.sparks.create({
+     *   payload: 'my secret data',
+     *   ttl: 3600,
+     *   maxReads: 1
+     * });
+     * console.log(spark.url);
+     */
+    create(options: CreateSparkOptions): Promise<Spark>;
+    /**
+     * Read and burn a spark.
+     * The spark is destroyed after the configured number of reads.
+     *
+     * @example
+     * const payload = await sv.sparks.read('spk_abc123');
+     * console.log(payload.data);
+     */
+    read(id: string, password?: string): Promise<SparkPayload>;
+    private validateCreateOptions;
+    private encodePayload;
+    private decodePayload;
+}
+export type { CreateSparkOptions, Spark, SparkPayload, } from './types';

package/dist/sparks/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Sparks Module Types
+ */
+export interface CreateSparkOptions {
+    /** Secret payload to encrypt */
+    payload: string | Uint8Array;
+    /** Time-to-live in seconds (default: 3600) */
+    ttl?: number;
+    /** Maximum number of reads before destruction (default: 1) */
+    maxReads?: number;
+    /** Optional password protection */
+    password?: string;
+    /** Optional name/label for the spark */
+    name?: string;
+}
+export interface Spark {
+    /** Spark ID */
+    id: string;
+    /** Direct URL to read the spark */
+    url: string;
+    /** Expiry timestamp (Unix seconds) */
+    expiresAt: number;
+    /** Maximum reads remaining */
+    maxReads: number;
+    /** Name/label if provided */
+    name?: string;
+}
+export interface ReadSparkOptions {
+    /** Spark ID */
+    id: string;
+    /** Password if the spark is password-protected */
+    password?: string;
+}
+export interface SparkPayload {
+    /** Decrypted data */
+    data: string | Uint8Array;
+    /** When the spark was read (Unix seconds) */
+    readAt: number;
+    /** Whether the spark was destroyed after reading */
+    burned: boolean;
+    /** Reads remaining (0 if burned) */
+    readsRemaining: number;
+}
+export interface CreateSparkResponse {
+    spark_id: string;
+    url: string;
+    expires_at: number;
+    max_reads: number;
+    name?: string;
+}
+export interface ReadSparkResponse {
+    payload: string;
+    read_at: number;
+    burned: boolean;
+    reads_remaining: number;
+}