vidjutsu 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,35 @@
+import createFetchClient from "openapi-fetch";
+import type { paths } from "./schema.js";
+import { type VidJutsuMethods } from "./methods.js";
+export interface VidJutsuConfig {
+    /** API key. Falls back to VIDJUTSU_API_KEY env var, then ~/.vidjutsu/config.json. */
+    apiKey?: string;
+    /** Base URL. Falls back to VIDJUTSU_API_URL env var, then ~/.vidjutsu/config.json, then https://api.vidjutsu.ai. */
+    baseUrl?: string;
+}
+/** The raw openapi-fetch client with typed GET/POST/PUT/DELETE */
+type FetchClient = ReturnType<typeof createFetchClient<paths>>;
+/** Combined client: typed convenience methods + raw openapi-fetch escape hatch */
+export type VidJutsuClient = VidJutsuMethods & {
+    api: FetchClient;
+};
+/**
+ * Create a typed VidJutsu API client.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'vidjutsu';
+ *
+ * const vj = createClient(); // reads ~/.vidjutsu/config.json or env vars
+ *
+ * // Convenience methods (fully typed):
+ * const { data } = await vj.watchMedia({ mediaUrl: 'https://...', prompt: '...' });
+ * const { data } = await vj.extractMedia({ mediaUrl: 'https://...', frames: 'auto' });
+ * const { data } = await vj.transcribeMedia({ mediaUrl: 'https://...' });
+ *
+ * // Raw openapi-fetch (escape hatch):
+ * const { data } = await vj.api.GET('/v1/balance');
+ * ```
+ */
+export declare function createClient(config?: VidJutsuConfig): VidJutsuClient;
+export {};

package/dist/client.js

@@ -0,0 +1,54 @@
+import createFetchClient from "openapi-fetch";
+import { bindMethods } from "./methods.js";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function readConfigFile() {
+    try {
+        const configPath = join(homedir(), ".vidjutsu", "config.json");
+        if (existsSync(configPath)) {
+            return JSON.parse(readFileSync(configPath, "utf-8"));
+        }
+    }
+    catch {
+        // Non-Node environments (edge, browser) — config file not available
+    }
+    return null;
+}
+/**
+ * Create a typed VidJutsu API client.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'vidjutsu';
+ *
+ * const vj = createClient(); // reads ~/.vidjutsu/config.json or env vars
+ *
+ * // Convenience methods (fully typed):
+ * const { data } = await vj.watchMedia({ mediaUrl: 'https://...', prompt: '...' });
+ * const { data } = await vj.extractMedia({ mediaUrl: 'https://...', frames: 'auto' });
+ * const { data } = await vj.transcribeMedia({ mediaUrl: 'https://...' });
+ *
+ * // Raw openapi-fetch (escape hatch):
+ * const { data } = await vj.api.GET('/v1/balance');
+ * ```
+ */
+export function createClient(config = {}) {
+    const configFile = readConfigFile();
+    const apiKey = config.apiKey ??
+        process.env.VIDJUTSU_API_KEY ??
+        configFile?.apiKey;
+    const baseUrl = config.baseUrl ??
+        process.env.VIDJUTSU_API_URL ??
+        configFile?.apiUrl ??
+        "https://api.vidjutsu.ai";
+    const fetchClient = createFetchClient({
+        baseUrl,
+        headers: {
+            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            "Content-Type": "application/json",
+        },
+    });
+    const methods = bindMethods(fetchClient);
+    return { ...methods, api: fetchClient };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createClient } from "./client.js";
+export type { VidJutsuConfig, VidJutsuClient } from "./client.js";
+export type { VidJutsuMethods } from "./methods.js";
+export type { paths, components } from "./schema.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { createClient } from "./client.js";

package/dist/methods.d.ts

@@ -0,0 +1,89 @@
+import type { paths } from "./schema.js";
+import type createFetchClient from "openapi-fetch";
+type Client = ReturnType<typeof createFetchClient<paths>>;
+type ReqBody<P extends keyof paths, M extends keyof paths[P]> = paths[P][M] extends {
+    requestBody: {
+        content: {
+            "application/json": infer B;
+        };
+    };
+} ? B : never;
+type QueryParams<P extends keyof paths, M extends keyof paths[P]> = paths[P][M] extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? Q : never;
+export interface VidJutsuMethods {
+    /** Create account Auth required. */
+    createAccount(body: ReqBody<"/v1/accounts", "post">): ReturnType<Client["POST"]>;
+    /** Update account Auth required. */
+    updateAccount(body: ReqBody<"/v1/accounts", "put">, query?: QueryParams<"/v1/accounts", "put">): ReturnType<Client["PUT"]>;
+    /** List accounts or get by ID Auth required. */
+    listOrGetAccounts(query?: QueryParams<"/v1/accounts", "get">): ReturnType<Client["GET"]>;
+    /** Delete account Auth required. */
+    deleteAccount(query?: QueryParams<"/v1/accounts", "delete">): ReturnType<Client["DELETE"]>;
+    /** Recover API key Public endpoint. */
+    recoverApiKey(body: ReqBody<"/v1/api_keys/recover", "post">): ReturnType<Client["POST"]>;
+    /** Rotate API key Auth required. */
+    rotateApiKey(): ReturnType<Client["POST"]>;
+    /** Create asset from existing URL Auth required. */
+    createAsset(body: ReqBody<"/v1/assets", "post">): ReturnType<Client["POST"]>;
+    /** Update asset metadata Auth required. */
+    updateAsset(body: ReqBody<"/v1/assets", "put">, query?: QueryParams<"/v1/assets", "put">): ReturnType<Client["PUT"]>;
+    /** List assets or get by ID Auth required. */
+    listOrGetAssets(query?: QueryParams<"/v1/assets", "get">): ReturnType<Client["GET"]>;
+    /** Delete asset (soft) Auth required. */
+    deleteAsset(query?: QueryParams<"/v1/assets", "delete">): ReturnType<Client["DELETE"]>;
+    /** Confirm email verification code Public endpoint. */
+    confirmVerification(body: ReqBody<"/v1/auth/verify/confirm", "post">): ReturnType<Client["POST"]>;
+    /** Request email verification code Public endpoint. */
+    requestVerification(body: ReqBody<"/v1/auth/verify/request", "post">): ReturnType<Client["POST"]>;
+    /** Get credit balance Auth required. */
+    getBalance(): ReturnType<Client["GET"]>;
+    /** Check spec Auth required. 5 credits. */
+    checkSpec(body: ReqBody<"/v1/check", "post">): ReturnType<Client["POST"]>;
+    /** Get check rules Auth required. */
+    getCheckRules(): ReturnType<Client["GET"]>;
+    /** Update check rules Auth required. */
+    updateCheckRules(body: ReqBody<"/v1/check/rules", "put">): ReturnType<Client["PUT"]>;
+    /** Create checkout session Public endpoint. */
+    createCheckout(body: ReqBody<"/v1/credits", "post">): ReturnType<Client["POST"]>;
+    /** Check checkout status Public endpoint. */
+    getCheckoutStatus(query?: QueryParams<"/v1/credits/status", "get">): ReturnType<Client["GET"]>;
+    /** Extract from media Auth required. 5 credits. */
+    extractMedia(body: ReqBody<"/v1/extract", "post">): ReturnType<Client["POST"]>;
+    /** API info Public endpoint. */
+    getInfo(): ReturnType<Client["GET"]>;
+    /** Burn text overlay onto video Auth required. 5 credits. */
+    createOverlay(body: ReqBody<"/v1/overlay", "post">): ReturnType<Client["POST"]>;
+    /** Create post Auth required. */
+    createPost(body: ReqBody<"/v1/posts", "post">): ReturnType<Client["POST"]>;
+    /** Update post Auth required. */
+    updatePost(body: ReqBody<"/v1/posts", "put">, query?: QueryParams<"/v1/posts", "put">): ReturnType<Client["PUT"]>;
+    /** List posts or get by ID Auth required. */
+    listOrGetPosts(query?: QueryParams<"/v1/posts", "get">): ReturnType<Client["GET"]>;
+    /** Delete post Auth required. */
+    deletePost(query?: QueryParams<"/v1/posts", "delete">): ReturnType<Client["DELETE"]>;
+    /** Get pricing Public endpoint. */
+    getPricing(): ReturnType<Client["GET"]>;
+    /** Create reference Auth required. */
+    createReference(body: ReqBody<"/v1/references", "post">): ReturnType<Client["POST"]>;
+    /** Update reference Auth required. */
+    updateReference(body: ReqBody<"/v1/references", "put">, query?: QueryParams<"/v1/references", "put">): ReturnType<Client["PUT"]>;
+    /** List references or get by ID Auth required. */
+    listOrGetReferences(query?: QueryParams<"/v1/references", "get">): ReturnType<Client["GET"]>;
+    /** Delete reference Auth required. */
+    deleteReference(query?: QueryParams<"/v1/references", "delete">): ReturnType<Client["DELETE"]>;
+    /** Create subscription Public endpoint. */
+    createSubscription(body: ReqBody<"/v1/subscribe", "post">): ReturnType<Client["POST"]>;
+    /** Transcribe media Auth required. 10 credits. */
+    transcribeMedia(body: ReqBody<"/v1/transcribe", "post">): ReturnType<Client["POST"]>;
+    /** Upload file Auth required. */
+    uploadFile(): ReturnType<Client["POST"]>;
+    /** Upload from URL Auth required. */
+    uploadFromUrl(body: ReqBody<"/v1/upload/url", "post">): ReturnType<Client["POST"]>;
+    /** Watch media Auth required. 10 credits. */
+    watchMedia(body: ReqBody<"/v1/watch", "post">): ReturnType<Client["POST"]>;
+}
+export declare function bindMethods(client: Client): VidJutsuMethods;
+export {};

package/dist/methods.js

@@ -0,0 +1,109 @@
+export function bindMethods(client) {
+    return {
+        createAccount(body) {
+            return client.POST("/v1/accounts", { body });
+        },
+        updateAccount(body, query) {
+            return client.PUT("/v1/accounts", { body, params: { query } });
+        },
+        listOrGetAccounts(query) {
+            return client.GET("/v1/accounts", { params: { query } });
+        },
+        deleteAccount(query) {
+            return client.DELETE("/v1/accounts", { params: { query } });
+        },
+        recoverApiKey(body) {
+            return client.POST("/v1/api_keys/recover", { body });
+        },
+        rotateApiKey() {
+            return client.POST("/v1/api_keys/rotate", {});
+        },
+        createAsset(body) {
+            return client.POST("/v1/assets", { body });
+        },
+        updateAsset(body, query) {
+            return client.PUT("/v1/assets", { body, params: { query } });
+        },
+        listOrGetAssets(query) {
+            return client.GET("/v1/assets", { params: { query } });
+        },
+        deleteAsset(query) {
+            return client.DELETE("/v1/assets", { params: { query } });
+        },
+        confirmVerification(body) {
+            return client.POST("/v1/auth/verify/confirm", { body });
+        },
+        requestVerification(body) {
+            return client.POST("/v1/auth/verify/request", { body });
+        },
+        getBalance() {
+            return client.GET("/v1/balance", {});
+        },
+        checkSpec(body) {
+            return client.POST("/v1/check", { body });
+        },
+        getCheckRules() {
+            return client.GET("/v1/check/rules", {});
+        },
+        updateCheckRules(body) {
+            return client.PUT("/v1/check/rules", { body });
+        },
+        createCheckout(body) {
+            return client.POST("/v1/credits", { body });
+        },
+        getCheckoutStatus(query) {
+            return client.GET("/v1/credits/status", { params: { query } });
+        },
+        extractMedia(body) {
+            return client.POST("/v1/extract", { body });
+        },
+        getInfo() {
+            return client.GET("/v1/info", {});
+        },
+        createOverlay(body) {
+            return client.POST("/v1/overlay", { body });
+        },
+        createPost(body) {
+            return client.POST("/v1/posts", { body });
+        },
+        updatePost(body, query) {
+            return client.PUT("/v1/posts", { body, params: { query } });
+        },
+        listOrGetPosts(query) {
+            return client.GET("/v1/posts", { params: { query } });
+        },
+        deletePost(query) {
+            return client.DELETE("/v1/posts", { params: { query } });
+        },
+        getPricing() {
+            return client.GET("/v1/pricing", {});
+        },
+        createReference(body) {
+            return client.POST("/v1/references", { body });
+        },
+        updateReference(body, query) {
+            return client.PUT("/v1/references", { body, params: { query } });
+        },
+        listOrGetReferences(query) {
+            return client.GET("/v1/references", { params: { query } });
+        },
+        deleteReference(query) {
+            return client.DELETE("/v1/references", { params: { query } });
+        },
+        createSubscription(body) {
+            return client.POST("/v1/subscribe", { body });
+        },
+        transcribeMedia(body) {
+            return client.POST("/v1/transcribe", { body });
+        },
+        uploadFile() {
+            return client.POST("/v1/upload", {});
+        },
+        uploadFromUrl(body) {
+            return client.POST("/v1/upload/url", { body });
+        },
+        watchMedia(body) {
+            return client.POST("/v1/watch", { body });
+        },
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "vidjutsu",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for the VidJutsu video intelligence API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "generate": "bun scripts/generate-schema.ts && bun scripts/generate-methods.ts",
+    "build": "tsc",
+    "prepublishOnly": "bun run generate && bun run build"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.13.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "openapi-typescript": "^7.8.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "vidjutsu",
+    "video",
+    "ai",
+    "api",
+    "sdk",
+    "watch",
+    "extract",
+    "transcribe"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tfcbot/vidjutsu-sdk"
+  }
+}