@videocensor/sdk 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+Все значимые изменения SDK документируются здесь. Формат — [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+Версионирование — [SemVer](https://semver.org/):
+
+- **MAJOR** — breaking changes: удаление endpoint, удаление или переименование поля, изменение типа поля
+- **MINOR** — новые endpoints, новые опциональные поля
+- **PATCH** — багфиксы клиента, улучшения retry/backoff, docs
+
+Breaking changes сопровождаются deprecation period не менее 3 месяцев в [Deprecated] секции до релиза MAJOR.
+
+## [1.0.0] — 2026-04-08
+
+Первый публичный релиз.
+
+### Added
+- `VideoCensor` client с методами: `analyzeText`, `censorText`, `analyzeMedia`, `censorMedia`, `analyzeMediaUrl`, `censorMediaUrl`, `listJobs`, `getJob`, `getJobResult`, `cancelJob`, `downloadJob`, `getTranscript`, `waitForJob`, `createBatch`, `getBatch`, `listWebhooks`, `createWebhook`, `deleteWebhook`, `getAccount`
+- Типизированные ошибки: `AuthenticationError`, `RateLimitError`, `BadRequestError`, `NotFoundError`, `VideoCensorError`
+- Exponential backoff retry (429/5xx) с Retry-After
+- Поддержка `vc_live_` и `vc_test_` API-ключей
+- Модели `JobStatus`, `JobResult` синхронизированы с публичным контрактом API (16 и 9 полей соответственно)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VideoCensor
+
+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,136 @@
+# @videocensor/sdk
+
+Node.js SDK for [VideoCensor](https://videocensor.ru) content moderation API.
+
+## Installation
+
+```bash
+npm install @videocensor/sdk
+```
+
+## Quick Start
+
+```typescript
+import { VideoCensor } from '@videocensor/sdk';
+
+const client = new VideoCensor({ apiKey: 'vc_live_...' });
+
+// Analyze text
+const result = await client.analyzeText('some text to check');
+console.log(result.flaggedCount, result.categories);
+
+// Censor text
+const censored = await client.censorText('some text to censor');
+console.log(censored.censored);
+
+// Analyze media file
+const job = await client.analyzeMedia('/path/to/video.mp4');
+const completed = await client.waitForJob(job.id);
+const analysis = await client.getJobResult(completed.id);
+
+// Censor media from URL
+const censorJob = await client.censorMediaUrl('https://youtube.com/watch?v=...');
+const done = await client.waitForJob(censorJob.id);
+await client.downloadJob(done.id, './censored.mp4');
+```
+
+## Configuration
+
+```typescript
+const client = new VideoCensor({
+  apiKey: 'vc_live_...',     // Required. Use vc_test_ for sandbox.
+  baseUrl: 'https://...',    // Optional. Default: https://videocensor.ru/api/v1
+  timeout: 30_000,           // Optional. Request timeout in ms.
+  maxRetries: 3,             // Optional. Retries on 429/5xx.
+});
+```
+
+## API
+
+### Text
+
+| Method | Description |
+|--------|-------------|
+| `analyzeText(text, options?)` | Analyze text for flagged content |
+| `censorText(text, options?)` | Replace flagged words with `***` |
+
+Options: `language`, `categories`, `preset`, `replacement` (censor only).
+
+### Media
+
+| Method | Description |
+|--------|-------------|
+| `analyzeMedia(filePath, options?)` | Upload and analyze media file |
+| `censorMedia(filePath, options?)` | Upload and censor media file |
+| `analyzeMediaUrl(url, options?)` | Analyze media from URL |
+| `censorMediaUrl(url, options?)` | Censor media from URL |
+
+Options: `language`, `mode`, `categories`, `preset`, `wayOfBlocking`, `censorStrength`.
+
+### Jobs
+
+| Method | Description |
+|--------|-------------|
+| `listJobs(options?)` | List jobs with pagination |
+| `getJob(jobId)` | Get job status |
+| `getJobResult(jobId)` | Get full analysis result |
+| `cancelJob(jobId)` | Cancel a job |
+| `downloadJob(jobId, outputPath)` | Download processed file |
+| `getTranscript(jobId, format?)` | Get transcription (srt/txt/json) |
+| `waitForJob(jobId, timeoutMs?)` | Poll until job completes |
+
+### Batch
+
+| Method | Description |
+|--------|-------------|
+| `createBatch(requests)` | Submit batch of text operations |
+| `getBatch(batchId)` | Get batch status and results |
+
+### Webhooks
+
+| Method | Description |
+|--------|-------------|
+| `listWebhooks()` | List webhook endpoints |
+| `createWebhook(url, events?)` | Create webhook endpoint |
+| `deleteWebhook(webhookId)` | Delete webhook endpoint |
+
+### Account
+
+| Method | Description |
+|--------|-------------|
+| `getAccount()` | Get account info and usage |
+
+## Error Handling
+
+```typescript
+import { VideoCensorError, RateLimitError, AuthenticationError } from '@videocensor/sdk';
+
+try {
+  await client.analyzeText('test');
+} catch (err) {
+  if (err instanceof RateLimitError) {
+    console.log(`Retry after ${err.retryAfter}s`);
+  }
+  if (err instanceof AuthenticationError) {
+    console.log('Invalid API key');
+  }
+}
+```
+
+## Content Categories
+
+`profanity`, `hate_speech`, `extremism`, `drugs`, `sexual`, `insults`
+
+## Requirements
+
+Node.js >= 18
+
+## Versioning
+
+This SDK follows [SemVer](https://semver.org/):
+
+- **MAJOR** — breaking changes (removed endpoints/fields, type changes). Deprecation notice at least 3 months in advance.
+- **MINOR** — new endpoints or optional fields.
+- **PATCH** — bugfixes, retry/backoff improvements, docs.
+
+See [CHANGELOG.md](./CHANGELOG.md) for release notes.

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+import type { TextAnalysisResult, TextCensorResult, JobStatus, JobResult, JobList, WebhookEndpoint, AccountInfo, BatchResult, AnalyzeTextOptions, CensorTextOptions, MediaOptions, CensorMediaOptions } from './models';
+export interface VideoCensorConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+export declare class VideoCensor {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(config: VideoCensorConfig);
+    analyzeText(text: string, options?: AnalyzeTextOptions): Promise<TextAnalysisResult>;
+    censorText(text: string, options?: CensorTextOptions): Promise<TextCensorResult>;
+    analyzeMedia(filePath: string, options?: MediaOptions): Promise<JobStatus>;
+    censorMedia(filePath: string, options?: CensorMediaOptions): Promise<JobStatus>;
+    analyzeMediaUrl(url: string, options?: MediaOptions): Promise<JobStatus>;
+    censorMediaUrl(url: string, options?: CensorMediaOptions): Promise<JobStatus>;
+    listJobs(options?: {
+        cursor?: string;
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<JobList>;
+    getJob(jobId: string): Promise<JobStatus>;
+    getJobResult(jobId: string): Promise<JobResult>;
+    cancelJob(jobId: string): Promise<void>;
+    downloadJob(jobId: string, outputPath: string): Promise<void>;
+    getTranscript(jobId: string, format?: 'srt' | 'txt' | 'json'): Promise<unknown>;
+    waitForJob(jobId: string, timeoutMs?: number): Promise<JobStatus>;
+    createBatch(requests: Array<{
+        method: string;
+        params: Record<string, unknown>;
+    }>): Promise<BatchResult>;
+    getBatch(batchId: string): Promise<BatchResult>;
+    listWebhooks(): Promise<WebhookEndpoint[]>;
+    createWebhook(url: string, events?: string[]): Promise<WebhookEndpoint>;
+    deleteWebhook(webhookId: string): Promise<void>;
+    getAccount(): Promise<AccountInfo>;
+    private get;
+    private post;
+    private postMedia;
+    private fetchWithRetry;
+    private throwResponseError;
+    private retryDelay;
+    private sleep;
+}

package/dist/client.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoCensor = void 0;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = 'https://videocensor.ru/api/v1';
+const POLL_INTERVAL_MS = 3_000;
+const MAX_POLL_ATTEMPTS = 200;
+const MAX_RETRIES = 3;
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+class VideoCensor {
+    baseUrl;
+    apiKey;
+    timeout;
+    maxRetries;
+    constructor(config) {
+        if (!config.apiKey?.startsWith('vc_live_') && !config.apiKey?.startsWith('vc_test_')) {
+            throw new errors_1.AuthenticationError("API key must start with 'vc_live_' or 'vc_test_'");
+        }
+        this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+        this.apiKey = config.apiKey;
+        this.timeout = config.timeout ?? 30_000;
+        this.maxRetries = config.maxRetries ?? MAX_RETRIES;
+    }
+    // ── Text ──
+    async analyzeText(text, options = {}) {
+        return this.post('/analyze/text', {
+            text,
+            language: options.language ?? 'ru',
+            categories: options.categories,
+            preset: options.preset ?? 'standard',
+        });
+    }
+    async censorText(text, options = {}) {
+        return this.post('/censor/text', {
+            text,
+            language: options.language ?? 'ru',
+            replacement: options.replacement ?? '***',
+            categories: options.categories,
+            preset: options.preset ?? 'standard',
+        });
+    }
+    // ── Media ──
+    async analyzeMedia(filePath, options = {}) {
+        return this.postMedia('/analyze/media', filePath, options);
+    }
+    async censorMedia(filePath, options = {}) {
+        return this.postMedia('/censor/media', filePath, options);
+    }
+    async analyzeMediaUrl(url, options = {}) {
+        return this.post('/analyze/media-url', {
+            url, language: options.language ?? 'ru', mode: options.mode ?? 'standard',
+            categories: options.categories, preset: options.preset ?? 'standard',
+        });
+    }
+    async censorMediaUrl(url, options = {}) {
+        return this.post('/censor/media-url', {
+            url, language: options.language ?? 'ru', mode: options.mode ?? 'standard',
+            categories: options.categories, preset: options.preset ?? 'standard',
+            wayOfBlocking: options.wayOfBlocking ?? 'beep',
+            censorStrength: options.censorStrength ?? 100,
+        });
+    }
+    // ── Jobs ──
+    async listJobs(options = {}) {
+        const params = new URLSearchParams();
+        if (options.cursor)
+            params.set('cursor', options.cursor);
+        else if (options.page)
+            params.set('page', String(options.page));
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.status)
+            params.set('status', options.status);
+        const qs = params.toString();
+        return this.get(`/jobs${qs ? `?${qs}` : ''}`);
+    }
+    async getJob(jobId) {
+        return this.get(`/jobs/${jobId}`);
+    }
+    async getJobResult(jobId) {
+        return this.get(`/jobs/${jobId}/result`);
+    }
+    async cancelJob(jobId) {
+        await this.post(`/jobs/${jobId}/cancel`);
+    }
+    async downloadJob(jobId, outputPath) {
+        const response = await this.fetchWithRetry(`/jobs/${jobId}/download`, { method: 'GET' });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        await (0, promises_1.writeFile)(outputPath, buffer);
+    }
+    async getTranscript(jobId, format = 'json') {
+        const response = await this.fetchWithRetry(`/jobs/${jobId}/transcript?format=${format}`, { method: 'GET' });
+        if (format === 'json')
+            return response.json();
+        return response.text();
+    }
+    async waitForJob(jobId, timeoutMs = 600_000) {
+        const deadline = Date.now() + timeoutMs;
+        for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+            if (Date.now() > deadline) {
+                throw new errors_1.VideoCensorError(`Job ${jobId} did not complete within ${timeoutMs}ms`);
+            }
+            const status = await this.getJob(jobId);
+            if (['done', 'error', 'cancelled'].includes(status.status))
+                return status;
+            await this.sleep(POLL_INTERVAL_MS);
+        }
+        throw new errors_1.VideoCensorError(`Job ${jobId} polling exceeded ${MAX_POLL_ATTEMPTS} attempts`);
+    }
+    // ── Batch ──
+    async createBatch(requests) {
+        return this.post('/batch', { requests });
+    }
+    async getBatch(batchId) {
+        return this.get(`/batch/${batchId}`);
+    }
+    // ── Webhooks ──
+    async listWebhooks() {
+        const data = await this.get('/webhooks');
+        return data.data;
+    }
+    async createWebhook(url, events) {
+        return this.post('/webhooks', { url, events });
+    }
+    async deleteWebhook(webhookId) {
+        await this.fetchWithRetry(`/webhooks/${webhookId}`, { method: 'DELETE' });
+    }
+    // ── Account ──
+    async getAccount() {
+        return this.get('/account');
+    }
+    // ── Internal ──
+    async get(path) {
+        const response = await this.fetchWithRetry(path, { method: 'GET' });
+        return response.json();
+    }
+    async post(path, body) {
+        const response = await this.fetchWithRetry(path, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return response.json();
+    }
+    async postMedia(path, filePath, options) {
+        const blob = typeof node_fs_1.openAsBlob === 'function'
+            ? await (0, node_fs_1.openAsBlob)(filePath)
+            : new Blob([await (0, promises_1.readFile)(filePath)]);
+        const form = new FormData();
+        form.append('file', blob, (0, node_path_1.basename)(filePath));
+        form.append('language', options.language ?? 'ru');
+        form.append('mode', options.mode ?? 'standard');
+        form.append('preset', options.preset ?? 'standard');
+        if (options.categories?.length) {
+            for (const cat of options.categories)
+                form.append('categories', cat);
+        }
+        if (options.wayOfBlocking)
+            form.append('wayOfBlocking', options.wayOfBlocking);
+        if (options.censorStrength !== undefined)
+            form.append('censorStrength', String(options.censorStrength));
+        const response = await this.fetchWithRetry(path, { method: 'POST', body: form });
+        return response.json();
+    }
+    async fetchWithRetry(path, init) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0) {
+                const delay = this.retryDelay(attempt, lastError);
+                await this.sleep(delay);
+            }
+            try {
+                const response = await globalThis.fetch(`${this.baseUrl}${path}`, {
+                    ...init,
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        ...init.headers,
+                    },
+                    signal: AbortSignal.timeout(this.timeout),
+                });
+                if (response.ok)
+                    return response;
+                if (!RETRYABLE_STATUSES.has(response.status) || attempt === this.maxRetries) {
+                    await this.throwResponseError(response);
+                }
+                lastError = new errors_1.VideoCensorError(`HTTP ${response.status}`, response.status);
+            }
+            catch (err) {
+                if (err instanceof errors_1.VideoCensorError)
+                    throw err;
+                if (attempt === this.maxRetries)
+                    throw err;
+                lastError = err;
+            }
+        }
+        throw lastError ?? new errors_1.VideoCensorError('Request failed after retries');
+    }
+    async throwResponseError(response) {
+        const status = response.status;
+        let message = `Request failed with status ${status}`;
+        try {
+            const body = await response.json();
+            if (body.detail)
+                message = body.detail;
+            else if (body.message)
+                message = body.message;
+        }
+        catch { /* body not JSON */ }
+        if (status === 401)
+            throw new errors_1.AuthenticationError(message);
+        if (status === 429) {
+            const retryAfter = parseInt(response.headers.get('retry-after') ?? '60', 10);
+            throw new errors_1.RateLimitError(message, retryAfter);
+        }
+        if (status === 400)
+            throw new errors_1.BadRequestError(message);
+        if (status === 404)
+            throw new errors_1.NotFoundError(message);
+        throw new errors_1.VideoCensorError(message, status);
+    }
+    retryDelay(attempt, lastError) {
+        if (lastError instanceof errors_1.RateLimitError && lastError.retryAfter) {
+            return lastError.retryAfter * 1000;
+        }
+        return Math.min(1000 * 2 ** (attempt - 1), 30_000);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.VideoCensor = VideoCensor;

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class VideoCensorError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+export declare class AuthenticationError extends VideoCensorError {
+    constructor(message: string);
+}
+export declare class RateLimitError extends VideoCensorError {
+    readonly retryAfter?: number | undefined;
+    constructor(message: string, retryAfter?: number | undefined);
+}
+export declare class BadRequestError extends VideoCensorError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends VideoCensorError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.BadRequestError = exports.RateLimitError = exports.AuthenticationError = exports.VideoCensorError = void 0;
+class VideoCensorError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'VideoCensorError';
+    }
+}
+exports.VideoCensorError = VideoCensorError;
+class AuthenticationError extends VideoCensorError {
+    constructor(message) {
+        super(message, 401);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class RateLimitError extends VideoCensorError {
+    retryAfter;
+    constructor(message, retryAfter) {
+        super(message, 429);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class BadRequestError extends VideoCensorError {
+    constructor(message) {
+        super(message, 400);
+        this.name = 'BadRequestError';
+    }
+}
+exports.BadRequestError = BadRequestError;
+class NotFoundError extends VideoCensorError {
+    constructor(message) {
+        super(message, 404);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { VideoCensor } from './client';
+export type { VideoCensorConfig } from './client';
+export { VideoCensorError, AuthenticationError, RateLimitError, BadRequestError, NotFoundError, } from './errors';
+export type { TextAnalysisResult, TextCensorResult, JobStatus, JobResult, JobList, WebhookEndpoint, AccountInfo, BatchResult, AnalyzeTextOptions, CensorTextOptions, MediaOptions, CensorMediaOptions, ContentFlag, FlaggedWord, CategorySummary, } from './models';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.BadRequestError = exports.RateLimitError = exports.AuthenticationError = exports.VideoCensorError = exports.VideoCensor = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "VideoCensor", { enumerable: true, get: function () { return client_1.VideoCensor; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "VideoCensorError", { enumerable: true, get: function () { return errors_1.VideoCensorError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return errors_1.BadRequestError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });

package/dist/models.d.ts

@@ -0,0 +1,118 @@
+export interface ContentFlag {
+    category: string;
+    severity: string;
+}
+export interface FlaggedWord {
+    text: string;
+    position: number;
+    flagged: boolean;
+    flags: ContentFlag[];
+}
+export interface CategorySummary {
+    count: number;
+    words: string[];
+}
+export interface TextAnalysisResult {
+    totalWords: number;
+    flaggedCount: number;
+    categories: Record<string, CategorySummary>;
+    words: FlaggedWord[];
+    cleanText: string;
+}
+export interface TextCensorResult {
+    censored: string;
+    replacements: number;
+    flags: Array<{
+        text: string;
+        position: number;
+        flags: ContentFlag[];
+    }>;
+}
+export interface JobStatus {
+    id: string;
+    status: string;
+    stage: string | null;
+    progress: number;
+    message: string | null;
+    censoredCount: number;
+    censoredWords: string[];
+    sourceOriginalName: string | null;
+    language: string | null;
+    transcriptionMode: string | null;
+    durationSec: number | null;
+    errorMessage: string | null;
+    errorCode: string | null;
+    downloadUrl: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WordTimestamp {
+    text: string;
+    start: number;
+    end: number;
+    confidence: number;
+}
+export interface CensoredWordTimestamp extends WordTimestamp {
+    flags: ContentFlag[];
+}
+export interface JobResult {
+    id: string;
+    status: string;
+    fullText: string | null;
+    censoredCount: number;
+    censoredWords: string[];
+    wordTimestamps: WordTimestamp[];
+    censoredTimestamps: CensoredWordTimestamp[];
+    chapters: unknown[] | null;
+    settings: Record<string, unknown> | null;
+}
+export interface JobList {
+    data: JobStatus[];
+    page?: number;
+    limit: number;
+    total?: number;
+    hasMore?: boolean;
+    nextCursor?: string;
+}
+export interface WebhookEndpoint {
+    id: string;
+    url: string;
+    events: string[];
+    active: boolean;
+    secret?: string;
+}
+export interface AccountInfo {
+    email?: string;
+    apiTier: string;
+    usage: Record<string, number>;
+    tierLimits: Record<string, unknown>;
+}
+export interface BatchResult {
+    batchId: string;
+    total: number;
+    completed: number;
+    failed: number;
+    status: string;
+    results: unknown[];
+}
+export interface AnalyzeTextOptions {
+    language?: string;
+    categories?: string[];
+    preset?: string;
+}
+export interface CensorTextOptions {
+    language?: string;
+    replacement?: string;
+    categories?: string[];
+    preset?: string;
+}
+export interface MediaOptions {
+    language?: string;
+    mode?: string;
+    categories?: string[];
+    preset?: string;
+}
+export interface CensorMediaOptions extends MediaOptions {
+    wayOfBlocking?: string;
+    censorStrength?: number;
+}

package/dist/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@videocensor/sdk",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for VideoCensor content moderation API — profanity detection, hate speech, censoring for text, audio and video.",
+  "keywords": [
+    "videocensor",
+    "content-moderation",
+    "profanity",
+    "profanity-filter",
+    "censor",
+    "moderation",
+    "speech-to-text",
+    "audio",
+    "video",
+    "api-client",
+    "sdk"
+  ],
+  "homepage": "https://videocensor.ru/developers",
+  "bugs": {
+    "url": "https://videocensor.ru/developers",
+    "email": "support@videocensor.ru"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dzhumaevn/videocensor.git",
+    "directory": "sdk/nodejs"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "VideoCensor",
+    "email": "support@videocensor.ru",
+    "url": "https://videocensor.ru"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}