docwal-sdk 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to the DocWal Node.js SDK will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2024-01-10
+
+### Added
+- Initial release of DocWal Node.js/TypeScript SDK
+- Full TypeScript support with complete type definitions
+- Credentials resource with full CRUD operations
+- Template management (create, list, update, delete)
+- Team member management (invite, list, update roles, deactivate, remove)
+- API key management (generate, regenerate, revoke, info)
+- Batch credential issuance (JSON array and ZIP upload)
+- File upload support for PDF documents using FormData
+- Comprehensive error handling with custom error classes
+- Full documentation with TypeScript examples
+- Express.js integration example
+
+### Features
+- Issue single credentials with optional PDF attachments
+- Batch issue up to 1000 credentials at once
+- Batch upload with ZIP files (CSV/JSON + PDFs)
+- List and filter credentials with pagination
+- Revoke credentials with audit trail
+- Resend claim links with configurable expiration
+- Download credential files as Buffer
+- Manage credential templates with schema validation
+- Team collaboration with role-based permissions
+- Secure API key authentication
+- Async/await pattern throughout
+- Axios-based HTTP client with interceptors
+
+### TypeScript
+- Full type definitions included
+- Interfaces for all request/response types
+- Generic error types with proper inheritance
+- IDE autocomplete support
+
+### Security
+- API key-based authentication
+- HTTPS-only communication
+- Input validation for all requests
+- Proper error handling without leaking sensitive data

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DocWal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,409 @@
+# DocWal Node.js SDK
+
+Official Node.js/TypeScript SDK for DocWal API - Issue and manage verifiable digital credentials.
+
+## Installation
+
+```bash
+npm install docwal-sdk
+```
+
+## Quick Start
+
+```typescript
+import { DocWalClient } from 'docwal-sdk';
+
+// Initialize client
+const client = new DocWalClient({
+  apiKey: 'docwal_live_xxxxx'
+});
+
+// Issue a credential
+const result = await client.credentials.issue({
+  templateId: 'template-123',
+  individualEmail: 'student@example.com',
+  credentialData: {
+    student_name: 'John Doe',
+    degree: 'Bachelor of Science',
+    major: 'Computer Science',
+    graduation_date: '2024-05-15',
+    gpa: '3.8'
+  }
+});
+
+console.log(`Credential issued! Doc ID: ${result.doc_id}`);
+console.log(`Claim token: ${result.claim_token}`);
+```
+
+## Authentication
+
+Get your API key from your DocWal dashboard:
+1. Login to https://docwal.com
+2. Navigate to Settings → API Keys
+3. Click "Generate API Key"
+4. Copy and store securely
+
+**Requirements:**
+- Pilot tier or above
+- Owner or Admin role
+
+## Environment Configuration
+
+```typescript
+// Production (default)
+const client = new DocWalClient({
+  apiKey: 'docwal_live_xxxxx'
+});
+
+// Staging
+const client = new DocWalClient({
+  apiKey: 'docwal_test_xxxxx',
+  baseUrl: 'https://sandbox.docwal.com/api'
+});
+
+// Custom timeout
+const client = new DocWalClient({
+  apiKey: 'docwal_live_xxxxx',
+  timeout: 60000  // milliseconds
+});
+```
+
+## TypeScript Support
+
+Full TypeScript support with type definitions included:
+
+```typescript
+import {
+  DocWalClient,
+  IssueCredentialParams,
+  IssueCredentialResponse,
+  Credential,
+  Template
+} from 'docwal-sdk';
+```
+
+## Usage Examples
+
+### Issue Single Credential
+
+```typescript
+// Basic credential
+const result = await client.credentials.issue({
+  templateId: 'template-123',
+  individualEmail: 'student@example.com',
+  credentialData: {
+    student_name: 'John Doe',
+    degree: 'Bachelor of Science',
+    graduation_date: '2024-05-15'
+  }
+});
+
+// With PDF attachment
+import fs from 'fs';
+
+const pdfBuffer = fs.readFileSync('certificate.pdf');
+const result = await client.credentials.issue({
+  templateId: 'template-123',
+  individualEmail: 'student@example.com',
+  credentialData: { student_name: 'John Doe' },
+  documentFile: pdfBuffer,
+  claimTokenExpiresHours: 168  // 7 days
+});
+```
+
+### Batch Issue Credentials
+
+```typescript
+const credentialsList = [
+  {
+    individual_email: 'student1@example.com',
+    credential_data: {
+      student_name: 'Alice Smith',
+      degree: 'Bachelor of Arts',
+      graduation_date: '2024-05-15'
+    }
+  },
+  {
+    individual_email: 'student2@example.com',
+    credential_data: {
+      student_name: 'Bob Johnson',
+      degree: 'Bachelor of Science',
+      graduation_date: '2024-05-15'
+    }
+  }
+];
+
+const result = await client.credentials.batchIssue(
+  'template-123',
+  credentialsList,
+  true  // send notifications
+);
+
+console.log(`Success: ${result.success_count}/${result.total_rows}`);
+```
+
+### Batch Upload with ZIP
+
+```typescript
+import fs from 'fs';
+
+// ZIP structure:
+// batch_credentials.zip
+// ├── credentials.csv
+// └── documents/
+//     ├── student001.pdf
+//     ├── student002.pdf
+//     └── student003.pdf
+
+const zipBuffer = fs.readFileSync('batch_credentials.zip');
+
+const result = await client.credentials.batchUpload(
+  'template-123',
+  zipBuffer,
+  true  // send notifications
+);
+
+console.log(`Processed: ${result.total_rows}`);
+console.log(`Success: ${result.success_count}`);
+console.log(`Failed: ${result.failure_count}`);
+
+for (const item of result.results) {
+  if (item.status === 'success') {
+    console.log(`Row ${item.row}: ${item.doc_id}`);
+  } else {
+    console.log(`Row ${item.row}: ${item.error}`);
+  }
+}
+```
+
+### List and Get Credentials
+
+```typescript
+// List all credentials
+const credentials = await client.credentials.list(50, 0);
+
+for (const cred of credentials) {
+  console.log(`${cred.doc_id}: ${cred.template_name}`);
+}
+
+// Get specific credential
+const credential = await client.credentials.get('DOC123456');
+console.log(`Issued to: ${credential.ownership?.individual_email}`);
+console.log(`Status: ${credential.ownership?.is_claimed ? 'Claimed' : 'Pending'}`);
+```
+
+### Revoke Credential
+
+```typescript
+const result = await client.credentials.revoke(
+  'DOC123456',
+  'Student expelled for academic misconduct'
+);
+console.log(result.message);
+```
+
+### Resend Claim Link
+
+```typescript
+const result = await client.credentials.resendClaimLink(
+  'DOC123456',
+  168  // 7 days
+);
+
+console.log(`Sent to: ${result.recipient_email}`);
+console.log(`Expires: ${result.claim_token_expires}`);
+```
+
+### Download Credential File
+
+```typescript
+import fs from 'fs';
+
+// Download PDF file
+const pdfBuffer = await client.credentials.download('DOC123456');
+fs.writeFileSync('credential.pdf', pdfBuffer);
+```
+
+## Template Management
+
+```typescript
+// List templates
+const templates = await client.templates.list();
+
+// Get template
+const template = await client.templates.get('template-123');
+
+// Create template
+const template = await client.templates.create({
+  name: 'Bachelor Degree Certificate',
+  description: 'Template for bachelor degree graduation certificates',
+  credentialType: 'certificate',
+  schema: {
+    student_name: {
+      type: 'string',
+      required: true,
+      label: 'Student Name'
+    },
+    degree: {
+      type: 'string',
+      required: true,
+      label: 'Degree Program'
+    },
+    graduation_date: {
+      type: 'date',
+      required: true,
+      label: 'Graduation Date'
+    }
+  },
+  version: '1.0'
+});
+
+// Update template
+await client.templates.update('template-123', {
+  description: 'Updated description'
+});
+
+// Delete template (soft delete)
+await client.templates.delete('template-123');
+```
+
+## API Key Management
+
+```typescript
+// Generate new API key (Owner/Admin only)
+const result = await client.apiKeys.generate();
+console.log(`New API key: ${result.api_key}`);
+console.log('⚠️  Store securely - shown only once!');
+
+// Get API key info
+const info = await client.apiKeys.info();
+console.log(`Masked key: ${info.api_key_masked}`);
+console.log(`Created: ${info.created_at}`);
+console.log(`Last used: ${info.last_used_at}`);
+
+// Regenerate API key
+const result = await client.apiKeys.regenerate();
+console.log(`New API key: ${result.api_key}`);
+
+// Revoke API key
+await client.apiKeys.revoke();
+```
+
+## Team Management
+
+```typescript
+// List team members
+const team = await client.team.list();
+console.log(`Active members: ${team.stats.active_members}`);
+console.log(`Pending invitations: ${team.stats.pending_invitations}`);
+
+// Check email before inviting
+const check = await client.team.checkEmail('newmember@university.edu');
+if (check.recommendation === 'add_directly') {
+  console.log('User exists - can add directly');
+} else if (check.recommendation === 'send_invitation') {
+  console.log("User doesn't exist - must send invitation");
+}
+
+// Invite team member
+const result = await client.team.invite({
+  email: 'newmember@university.edu',
+  role: 'issuer',
+  sendEmail: true
+});
+
+// Update member role
+await client.team.updateRole('member-123', 'admin');
+
+// Deactivate member
+await client.team.deactivate('member-123', 'Employee on leave');
+
+// Reactivate member
+await client.team.reactivate('member-123');
+
+// Remove member permanently
+await client.team.remove('member-123');
+```
+
+## Error Handling
+
+```typescript
+import {
+  DocWalClient,
+  AuthenticationError,
+  ValidationError,
+  NotFoundError,
+  RateLimitError
+} from 'docwal-sdk';
+
+const client = new DocWalClient({ apiKey: 'docwal_live_xxxxx' });
+
+try {
+  const result = await client.credentials.issue({
+    templateId: 'invalid-template',
+    individualEmail: 'student@example.com',
+    credentialData: {}
+  });
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error('Authentication failed:', error.message);
+    console.error('Check your API key');
+  } else if (error instanceof ValidationError) {
+    console.error('Validation error:', error.message);
+    console.error('Check required fields');
+  } else if (error instanceof NotFoundError) {
+    console.error('Resource not found:', error.message);
+  } else if (error instanceof RateLimitError) {
+    console.error('Rate limit exceeded');
+  } else {
+    console.error('Error:', error);
+  }
+}
+```
+
+## Rate Limits
+
+- **Pilot**: 500 requests/hour
+- **Standard**: 1,000 requests/hour
+- **Enterprise**: Unlimited
+
+When rate limit is exceeded, `RateLimitError` is thrown.
+
+## Express.js Integration Example
+
+```typescript
+import express from 'express';
+import { DocWalClient } from 'docwal-sdk';
+
+const app = express();
+const docwal = new DocWalClient({ apiKey: process.env.DOCWAL_API_KEY! });
+
+app.use(express.json());
+
+app.post('/api/issue-credential', async (req, res) => {
+  try {
+    const result = await docwal.credentials.issue({
+      templateId: req.body.template_id,
+      individualEmail: req.body.email,
+      credentialData: req.body.data
+    });
+
+    res.json({ success: true, data: result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+app.listen(3000);
+```
+
+## Support
+
+- **Email**: support@docwal.com
+- **Documentation**: https://docs.docwal.com
+- **API Reference**: https://docwal.com/api/docs
+- **GitHub**: https://github.com/docwal/docwal-nodejs
+
+## License
+
+MIT License - see LICENSE file for details.

package/dist/index.d.ts

@@ -0,0 +1,250 @@
+/**
+ * DocWal Node.js SDK
+ *
+ * Official Node.js SDK for DocWal API - Issue and manage verifiable digital credentials.
+ */
+import { AxiosInstance } from 'axios';
+import { Readable } from 'stream';
+export interface DocWalConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export interface CredentialData {
+    [key: string]: any;
+}
+export interface IssueCredentialParams {
+    templateId: string;
+    individualEmail: string;
+    credentialData: CredentialData;
+    documentFile?: Buffer | Readable;
+    expiresAt?: string;
+    claimTokenExpiresHours?: number;
+}
+export interface IssueCredentialResponse {
+    doc_id: string;
+    document_hash: string;
+    status: string;
+    claim_token: string;
+}
+export interface BatchCredential {
+    individual_email: string;
+    credential_data: CredentialData;
+}
+export interface BatchIssueResponse {
+    total_rows: number;
+    success_count: number;
+    failure_count: number;
+    results: Array<{
+        row: number;
+        status: string;
+        doc_id?: string;
+        error?: string;
+    }>;
+}
+export interface Credential {
+    doc_id: string;
+    document_hash: string;
+    issued_at: string;
+    expires_at?: string;
+    is_revoked: boolean;
+    revoked_at?: string;
+    revocation_reason?: string;
+    template_name: string;
+    credential_data: CredentialData;
+    ownership?: {
+        individual_email: string;
+        is_claimed: boolean;
+        claimed_at?: string;
+        claim_token_expires?: string;
+    };
+    has_document_file: boolean;
+}
+export interface Template {
+    id: string;
+    name: string;
+    description: string;
+    credential_type: string;
+    schema: Record<string, any>;
+    version: string;
+    is_active: boolean;
+}
+export interface TeamMember {
+    id: string;
+    user: {
+        email: string;
+        full_name: string;
+    };
+    role: 'owner' | 'admin' | 'issuer';
+    is_active: boolean;
+    created_at: string;
+}
+export declare class DocWalError extends Error {
+    statusCode?: number | undefined;
+    response?: any | undefined;
+    constructor(message: string, statusCode?: number | undefined, response?: any | undefined);
+}
+export declare class AuthenticationError extends DocWalError {
+    constructor(message: string, statusCode?: number, response?: any);
+}
+export declare class ValidationError extends DocWalError {
+    constructor(message: string, statusCode?: number, response?: any);
+}
+export declare class RateLimitError extends DocWalError {
+    constructor(message: string, statusCode?: number, response?: any);
+}
+export declare class NotFoundError extends DocWalError {
+    constructor(message: string, statusCode?: number, response?: any);
+}
+/**
+ * DocWal API Client
+ */
+export declare class DocWalClient {
+    private client;
+    credentials: CredentialsResource;
+    templates: TemplatesResource;
+    apiKeys: APIKeysResource;
+    team: TeamResource;
+    constructor(config: DocWalConfig);
+}
+/**
+ * Credentials Resource
+ */
+declare class CredentialsResource {
+    private client;
+    constructor(client: AxiosInstance);
+    /**
+     * Issue a single credential
+     */
+    issue(params: IssueCredentialParams): Promise<IssueCredentialResponse>;
+    /**
+     * Issue multiple credentials in batch
+     */
+    batchIssue(templateId: string, credentials: BatchCredential[], sendNotifications?: boolean): Promise<BatchIssueResponse>;
+    /**
+     * Batch upload with ZIP file
+     */
+    batchUpload(templateId: string, file: Buffer | Readable, sendNotifications?: boolean): Promise<BatchIssueResponse>;
+    /**
+     * List all credentials
+     */
+    list(limit?: number, offset?: number): Promise<Credential[]>;
+    /**
+     * Get credential by doc_id
+     */
+    get(docId: string): Promise<Credential>;
+    /**
+     * Revoke credential
+     */
+    revoke(docId: string, reason: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Resend claim link
+     */
+    resendClaimLink(docId: string, claimTokenExpiresHours?: number): Promise<{
+        message: string;
+        claim_token: string;
+        claim_token_expires: string;
+        recipient_email: string;
+    }>;
+    /**
+     * Download credential file
+     */
+    download(docId: string): Promise<Buffer>;
+}
+/**
+ * Templates Resource
+ */
+declare class TemplatesResource {
+    private client;
+    constructor(client: AxiosInstance);
+    list(): Promise<Template[]>;
+    get(templateId: string): Promise<Template>;
+    create(params: {
+        name: string;
+        description: string;
+        credentialType: string;
+        schema: Record<string, any>;
+        version?: string;
+    }): Promise<Template>;
+    update(templateId: string, updates: Partial<Template>): Promise<Template>;
+    delete(templateId: string): Promise<{
+        message: string;
+    }>;
+}
+/**
+ * API Keys Resource
+ */
+declare class APIKeysResource {
+    private client;
+    constructor(client: AxiosInstance);
+    generate(): Promise<{
+        api_key: string;
+        created_at: string;
+        warning: string;
+    }>;
+    info(): Promise<{
+        has_api_key: boolean;
+        api_key_masked?: string;
+        created_at?: string;
+        last_used_at?: string;
+        is_active: boolean;
+    }>;
+    regenerate(): Promise<{
+        api_key: string;
+        created_at: string;
+        warning: string;
+    }>;
+    revoke(): Promise<{
+        message: string;
+        revoked_at: string;
+    }>;
+}
+/**
+ * Team Resource
+ */
+declare class TeamResource {
+    private client;
+    constructor(client: AxiosInstance);
+    list(): Promise<{
+        members: TeamMember[];
+        pending_invitations: any[];
+        stats: {
+            total_members: number;
+            active_members: number;
+            tier_limit: number | null;
+        };
+    }>;
+    checkEmail(email: string): Promise<{
+        valid: boolean;
+        domain_matches: boolean;
+        user_exists: boolean;
+        is_already_member: boolean;
+        recommendation: string;
+    }>;
+    invite(params: {
+        email: string;
+        role?: 'owner' | 'admin' | 'issuer';
+        sendEmail?: boolean;
+        addDirectly?: boolean;
+    }): Promise<{
+        message: string;
+        invitation?: any;
+        member?: TeamMember;
+    }>;
+    updateRole(memberId: string, role: string): Promise<{
+        message: string;
+        member: TeamMember;
+    }>;
+    deactivate(memberId: string, reason?: string): Promise<{
+        message: string;
+    }>;
+    reactivate(memberId: string): Promise<{
+        message: string;
+    }>;
+    remove(memberId: string): Promise<{
+        message: string;
+    }>;
+}
+export default DocWalClient;

package/dist/index.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * DocWal Node.js SDK
+ *
+ * Official Node.js SDK for DocWal API - Issue and manage verifiable digital credentials.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocWalClient = exports.NotFoundError = exports.RateLimitError = exports.ValidationError = exports.AuthenticationError = exports.DocWalError = void 0;
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+// Errors
+class DocWalError extends Error {
+    constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'DocWalError';
+    }
+}
+exports.DocWalError = DocWalError;
+class AuthenticationError extends DocWalError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class ValidationError extends DocWalError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class RateLimitError extends DocWalError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class NotFoundError extends DocWalError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * DocWal API Client
+ */
+class DocWalClient {
+    constructor(config) {
+        const { apiKey, baseUrl = 'https://docwal.com/api', timeout = 30000 } = config;
+        this.client = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout,
+            headers: {
+                'X-API-Key': apiKey,
+                'Content-Type': 'application/json',
+            },
+        });
+        // Error interceptor
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                const message = data?.error || error.message;
+                if (status === 401) {
+                    throw new AuthenticationError(message, status, error.response);
+                }
+                else if (status === 400) {
+                    throw new ValidationError(message, status, error.response);
+                }
+                else if (status === 404) {
+                    throw new NotFoundError(message, status, error.response);
+                }
+                else if (status === 429) {
+                    throw new RateLimitError(message, status, error.response);
+                }
+                else {
+                    throw new DocWalError(message, status, error.response);
+                }
+            }
+            else if (error.request) {
+                throw new DocWalError('No response from server');
+            }
+            else {
+                throw new DocWalError(error.message);
+            }
+        });
+        // Initialize resources
+        this.credentials = new CredentialsResource(this.client);
+        this.templates = new TemplatesResource(this.client);
+        this.apiKeys = new APIKeysResource(this.client);
+        this.team = new TeamResource(this.client);
+    }
+}
+exports.DocWalClient = DocWalClient;
+/**
+ * Credentials Resource
+ */
+class CredentialsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Issue a single credential
+     */
+    async issue(params) {
+        const { templateId, individualEmail, credentialData, documentFile, expiresAt, claimTokenExpiresHours = 720, } = params;
+        if (documentFile) {
+            const formData = new form_data_1.default();
+            formData.append('template_id', templateId);
+            formData.append('individual_email', individualEmail);
+            formData.append('credential_data', JSON.stringify(credentialData));
+            formData.append('claim_token_expires_hours', claimTokenExpiresHours.toString());
+            if (expiresAt) {
+                formData.append('expires_at', expiresAt);
+            }
+            formData.append('document_file', documentFile, 'document.pdf');
+            const response = await this.client.post('/credentials/issue/', formData, {
+                headers: formData.getHeaders(),
+            });
+            return response.data;
+        }
+        else {
+            const response = await this.client.post('/credentials/issue/', {
+                template_id: templateId,
+                individual_email: individualEmail,
+                credential_data: credentialData,
+                claim_token_expires_hours: claimTokenExpiresHours,
+                ...(expiresAt && { expires_at: expiresAt }),
+            });
+            return response.data;
+        }
+    }
+    /**
+     * Issue multiple credentials in batch
+     */
+    async batchIssue(templateId, credentials, sendNotifications = true) {
+        const response = await this.client.post('/credentials/batch/', {
+            template_id: templateId,
+            credentials,
+            send_notifications: sendNotifications,
+        });
+        return response.data;
+    }
+    /**
+     * Batch upload with ZIP file
+     */
+    async batchUpload(templateId, file, sendNotifications = true) {
+        const formData = new form_data_1.default();
+        formData.append('template_id', templateId);
+        formData.append('send_notifications', sendNotifications.toString());
+        formData.append('file', file, 'batch.zip');
+        const response = await this.client.post('/credentials/batch-upload/', formData, {
+            headers: formData.getHeaders(),
+        });
+        return response.data;
+    }
+    /**
+     * List all credentials
+     */
+    async list(limit = 100, offset = 0) {
+        const response = await this.client.get('/credentials/', {
+            params: { limit, offset },
+        });
+        return response.data;
+    }
+    /**
+     * Get credential by doc_id
+     */
+    async get(docId) {
+        const response = await this.client.get(`/credentials/${docId}/`);
+        return response.data;
+    }
+    /**
+     * Revoke credential
+     */
+    async revoke(docId, reason) {
+        const response = await this.client.post(`/credentials/${docId}/revoke/`, {
+            reason,
+        });
+        return response.data;
+    }
+    /**
+     * Resend claim link
+     */
+    async resendClaimLink(docId, claimTokenExpiresHours = 720) {
+        const response = await this.client.post(`/credentials/${docId}/resend-claim/`, {
+            claim_token_expires_hours: claimTokenExpiresHours,
+        });
+        return response.data;
+    }
+    /**
+     * Download credential file
+     */
+    async download(docId) {
+        const response = await this.client.get(`/credentials/${docId}/download/`, {
+            responseType: 'arraybuffer',
+        });
+        return Buffer.from(response.data);
+    }
+}
+/**
+ * Templates Resource
+ */
+class TemplatesResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        const response = await this.client.get('/templates/');
+        return response.data;
+    }
+    async get(templateId) {
+        const response = await this.client.get(`/templates/${templateId}/`);
+        return response.data;
+    }
+    async create(params) {
+        const response = await this.client.post('/templates/', {
+            name: params.name,
+            description: params.description,
+            credential_type: params.credentialType,
+            schema: params.schema,
+            version: params.version || '1.0',
+        });
+        return response.data;
+    }
+    async update(templateId, updates) {
+        const response = await this.client.patch(`/templates/${templateId}/`, updates);
+        return response.data;
+    }
+    async delete(templateId) {
+        const response = await this.client.delete(`/templates/${templateId}/`);
+        return response.data;
+    }
+}
+/**
+ * API Keys Resource
+ */
+class APIKeysResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async generate() {
+        const response = await this.client.post('/institutions/api-keys/generate/');
+        return response.data;
+    }
+    async info() {
+        const response = await this.client.get('/institutions/api-keys/info/');
+        return response.data;
+    }
+    async regenerate() {
+        const response = await this.client.post('/institutions/api-keys/regenerate/');
+        return response.data;
+    }
+    async revoke() {
+        const response = await this.client.post('/institutions/api-keys/revoke/');
+        return response.data;
+    }
+}
+/**
+ * Team Resource
+ */
+class TeamResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        const response = await this.client.get('/institutions/team/');
+        return response.data;
+    }
+    async checkEmail(email) {
+        const response = await this.client.post('/institutions/team/check-email/', {
+            email,
+        });
+        return response.data;
+    }
+    async invite(params) {
+        const response = await this.client.post('/institutions/team/invite/', {
+            email: params.email,
+            role: params.role || 'issuer',
+            send_email: params.sendEmail !== false,
+            add_directly: params.addDirectly || false,
+        });
+        return response.data;
+    }
+    async updateRole(memberId, role) {
+        const response = await this.client.patch(`/institutions/team/members/${memberId}/role/`, {
+            role,
+        });
+        return response.data;
+    }
+    async deactivate(memberId, reason) {
+        const response = await this.client.post(`/institutions/team/members/${memberId}/deactivate/`, {
+            ...(reason && { reason }),
+        });
+        return response.data;
+    }
+    async reactivate(memberId) {
+        const response = await this.client.post(`/institutions/team/members/${memberId}/reactivate/`);
+        return response.data;
+    }
+    async remove(memberId) {
+        const response = await this.client.delete(`/institutions/team/members/${memberId}/remove/`);
+        return response.data;
+    }
+}
+exports.default = DocWalClient;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "docwal-sdk",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for DocWal API - Issue and manage verifiable digital credentials",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "docwal",
+    "credentials",
+    "verifiable",
+    "digital",
+    "education",
+    "blockchain"
+  ],
+  "author": "DocWal <support@docwal.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/docwal/docwal-nodejs"
+  },
+  "bugs": {
+    "url": "https://github.com/docwal/docwal-nodejs/issues"
+  },
+  "homepage": "https://docs.docwal.com",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "form-data": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}