@foru-ms/sdk 0.1.0

package/dist/Client.d.ts

@@ -0,0 +1,21 @@
+import { AuthResource } from './resources/Auth';
+import { ThreadsResource } from './resources/Threads';
+import { PostsResource } from './resources/Posts';
+import { UsersResource } from './resources/Users';
+import { TagsResource } from './resources/Tags';
+export declare class ForumClient {
+    apiKey: string;
+    token: string | null;
+    baseUrl: string;
+    auth: AuthResource;
+    threads: ThreadsResource;
+    posts: PostsResource;
+    users: UsersResource;
+    tags: TagsResource;
+    constructor(options: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    request<T>(path: string, options?: RequestInit): Promise<T>;
+    setToken(token: string): void;
+}

package/dist/Client.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForumClient = void 0;
+const Auth_1 = require("./resources/Auth");
+const Threads_1 = require("./resources/Threads");
+const Posts_1 = require("./resources/Posts");
+const Users_1 = require("./resources/Users");
+const Tags_1 = require("./resources/Tags");
+// Polyfill fetch if needed (e.g. older Node versions)
+const fetch = globalThis.fetch || require('cross-fetch');
+class ForumClient {
+    constructor(options) {
+        this.token = null;
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl || 'https://api.foru.ms/v1';
+        this.auth = new Auth_1.AuthResource(this);
+        this.threads = new Threads_1.ThreadsResource(this);
+        this.posts = new Posts_1.PostsResource(this);
+        this.users = new Users_1.UsersResource(this);
+        this.tags = new Tags_1.TagsResource(this);
+    }
+    async request(path, options = {}) {
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            ...options.headers,
+        };
+        if (this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            headers,
+        });
+        const contentType = response.headers.get('content-type');
+        let data;
+        if (contentType && contentType.includes('application/json')) {
+            data = await response.json();
+        }
+        else {
+            data = await response.text();
+        }
+        if (!response.ok) {
+            throw new Error((data && data.message) || data.error || 'API Error');
+        }
+        return data;
+    }
+    setToken(token) {
+        this.token = token;
+    }
+}
+exports.ForumClient = ForumClient;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Client';
+export * from './types';
+export * from './resources/Auth';
+export * from './resources/Threads';
+export * from './resources/Posts';
+export * from './resources/Users';
+export * from './resources/Tags';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./resources/Auth"), exports);
+__exportStar(require("./resources/Threads"), exports);
+__exportStar(require("./resources/Posts"), exports);
+__exportStar(require("./resources/Users"), exports);
+__exportStar(require("./resources/Tags"), exports);

package/dist/resources/Auth.d.ts

@@ -0,0 +1,12 @@
+import { ForumClient } from '../Client';
+import { LoginResponse } from '../types';
+export declare class AuthResource {
+    private client;
+    constructor(client: ForumClient);
+    login(payload: {
+        login: string;
+        password: string;
+    }): Promise<LoginResponse>;
+    register(payload: import('../types').RegisterPayload): Promise<import('../types').User>;
+    me(): Promise<import('../types').User>;
+}

package/dist/resources/Auth.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResource = void 0;
+class AuthResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async login(payload) {
+        const response = await this.client.request('/auth/login', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+        if (response.token) {
+            this.client.setToken(response.token);
+        }
+        return response;
+    }
+    async register(payload) {
+        return this.client.request('/auth/register', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async me() {
+        return this.client.request('/auth/me', {
+            method: 'GET',
+        });
+    }
+}
+exports.AuthResource = AuthResource;

package/dist/resources/Posts.d.ts

@@ -0,0 +1,21 @@
+import { ForumClient } from '../Client';
+import { PostListResponse, InteractionType } from '../types';
+export declare class PostsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        query?: string;
+        filter?: 'newest' | 'oldest';
+        type?: InteractionType;
+        cursor?: string;
+        userId?: string;
+    }): Promise<PostListResponse>;
+    create(payload: import('../types').CreatePostPayload): Promise<import('../types').Post>;
+    retrieve(postId: string): Promise<import('../types').Post>;
+    update(postId: string, payload: import('../types').UpdatePostPayload): Promise<import('../types').Post>;
+    delete(postId: string, payload?: {
+        userId: string;
+    }): Promise<import('../types').Post & {
+        deleted: boolean;
+    }>;
+}

package/dist/resources/Posts.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostsResource = void 0;
+class PostsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/posts?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/post', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(postId) {
+        return this.client.request(`/post/${postId}`, {
+            method: 'GET',
+        });
+    }
+    async update(postId, payload) {
+        return this.client.request(`/post/${postId}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(postId, payload) {
+        return this.client.request(`/post/${postId}`, {
+            method: 'DELETE',
+            body: payload ? JSON.stringify(payload) : undefined,
+        });
+    }
+}
+exports.PostsResource = PostsResource;

package/dist/resources/Tags.d.ts

@@ -0,0 +1,10 @@
+import { ForumClient } from '../Client';
+import { TagListResponse } from '../types';
+export declare class TagsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        query?: string;
+        cursor?: string;
+    }): Promise<TagListResponse>;
+}

package/dist/resources/Tags.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagsResource = void 0;
+class TagsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/tags?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}
+exports.TagsResource = TagsResource;

package/dist/resources/Threads.d.ts

@@ -0,0 +1,22 @@
+import { ForumClient } from '../Client';
+import { ThreadListResponse, ThreadFilter, InteractionType } from '../types';
+export declare class ThreadsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        query?: string;
+        tagId?: string;
+        filter?: ThreadFilter;
+        type?: InteractionType;
+        cursor?: string;
+        userId?: string;
+    }): Promise<ThreadListResponse>;
+    create(payload: import('../types').CreateThreadPayload): Promise<import('../types').Thread>;
+    retrieve(threadId: string): Promise<import('../types').Thread>;
+    update(threadId: string, payload: import('../types').UpdateThreadPayload): Promise<import('../types').Thread>;
+    delete(threadId: string, payload?: {
+        userId: string;
+    }): Promise<import('../types').Thread & {
+        deleted: boolean;
+    }>;
+}

package/dist/resources/Threads.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadsResource = void 0;
+class ThreadsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/threads?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/thread', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(threadId) {
+        return this.client.request(`/thread/${threadId}`, {
+            method: 'GET',
+        });
+    }
+    async update(threadId, payload) {
+        return this.client.request(`/thread/${threadId}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(threadId, payload) {
+        return this.client.request(`/thread/${threadId}`, {
+            method: 'DELETE',
+            body: payload ? JSON.stringify(payload) : undefined,
+        });
+    }
+}
+exports.ThreadsResource = ThreadsResource;

package/dist/resources/Users.d.ts

@@ -0,0 +1,12 @@
+import { ForumClient } from '../Client';
+import { UserListResponse, User } from '../types';
+export declare class UsersResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        query?: string;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<UserListResponse>;
+    retrieve(userId: string): Promise<User>;
+}

package/dist/resources/Users.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersResource = void 0;
+class UsersResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/users?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async retrieve(userId) {
+        return this.client.request(`/user/${userId}`, {
+            method: 'GET',
+        });
+    }
+}
+exports.UsersResource = UsersResource;

package/dist/types.d.ts

@@ -0,0 +1,138 @@
+export interface RegisterPayload {
+    username: string;
+    email: string;
+    password: string;
+    displayName?: string;
+    emailVerified?: boolean;
+    roles?: string[];
+    extendedData?: Record<string, any>;
+}
+export interface User {
+    id: string;
+    username: string;
+    email?: string;
+    displayName: string | null;
+    roles?: any[];
+    extendedData?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface Thread {
+    id: string;
+    title: string;
+    slug: string;
+    body: string;
+    userId: string;
+    locked: boolean;
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+    likes?: any[];
+    upvotes?: any[];
+    tags?: any[];
+    poll?: any;
+    extendedData?: Record<string, any>;
+    _count?: {
+        Post: number;
+        likes?: number;
+        upvotes?: number;
+    };
+}
+export interface CreateThreadPayload {
+    title: string;
+    body: string;
+    userId?: string;
+    slug?: string;
+    locked?: boolean;
+    pinned?: boolean;
+    tags?: string[];
+    poll?: {
+        title: string;
+        options: {
+            title: string;
+            color?: string;
+            extendedData?: Record<string, any>;
+        }[];
+    };
+    extendedData?: Record<string, any>;
+}
+export interface UpdateThreadPayload {
+    title?: string;
+    slug?: string;
+    body?: string;
+    userId?: string;
+    locked?: boolean;
+    pinned?: boolean;
+    extendedData?: Record<string, any>;
+}
+export interface Post {
+    id: string;
+    body: string;
+    threadId: string;
+    userId: string;
+    parentId?: string | null;
+    depth?: number;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+    Thread?: {
+        userId: string;
+        title: string;
+    };
+    extendedData?: Record<string, any>;
+}
+export interface CreatePostPayload {
+    body: string;
+    threadId: string;
+    userId?: string;
+    parentId?: string;
+    extendedData?: Record<string, any>;
+}
+export interface UpdatePostPayload {
+    body?: string;
+    userId?: string;
+    threadId?: string;
+    parentId?: string;
+    bestAnswer?: boolean;
+    extendedData?: Record<string, any>;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+}
+export interface ThreadListResponse {
+    threads: Thread[];
+    nextThreadCursor?: string;
+    count: number;
+}
+export interface PostListResponse {
+    posts: Post[];
+    nextPostCursor?: string;
+    count: number;
+}
+export interface LoginResponse {
+    token: string;
+}
+export type ThreadFilter = 'newest' | 'oldest';
+export type InteractionType = 'created' | 'liked' | 'disliked' | 'upvoted' | 'downvoted' | 'subscribed';
+export interface Tag {
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        threads: number;
+    };
+    threads?: Thread[];
+}
+export interface UserListResponse {
+    users: User[];
+    nextUserCursor?: string;
+    count: number;
+}
+export interface TagListResponse {
+    tags: Tag[];
+    nextTagCursor?: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@foru-ms/sdk",
+    "version": "0.1.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "cross-fetch": "^3.1.5"
+    },
+    "devDependencies": {
+        "typescript": "^4.9.0",
+        "@types/node": "^18.0.0"
+    }
+}

package/src/Client.ts

@@ -0,0 +1,66 @@
+import { AuthResource } from './resources/Auth';
+import { ThreadsResource } from './resources/Threads';
+import { PostsResource } from './resources/Posts';
+import { UsersResource } from './resources/Users';
+import { TagsResource } from './resources/Tags';
+
+// Polyfill fetch if needed (e.g. older Node versions)
+const fetch = globalThis.fetch || require('cross-fetch');
+
+export class ForumClient {
+    public apiKey: string;
+    public token: string | null = null;
+    public baseUrl: string;
+
+    public auth: AuthResource;
+    public threads: ThreadsResource;
+    public posts: PostsResource;
+    public users: UsersResource;
+    public tags: TagsResource;
+
+    constructor(options: { apiKey: string; baseUrl?: string }) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl || 'https://api.foru.ms/v1';
+
+        this.auth = new AuthResource(this);
+        this.threads = new ThreadsResource(this);
+        this.posts = new PostsResource(this);
+        this.users = new UsersResource(this);
+        this.tags = new TagsResource(this);
+    }
+
+    public async request<T>(path: string, options: RequestInit = {}): Promise<T> {
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            ...(options.headers as Record<string, string>),
+        };
+
+        if (this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            headers,
+        });
+
+        const contentType = response.headers.get('content-type');
+        let data;
+        if (contentType && contentType.includes('application/json')) {
+            data = await response.json();
+        } else {
+            data = await response.text();
+        }
+
+        if (!response.ok) {
+            throw new Error((data && (data as any).message) || (data as any).error || 'API Error');
+        }
+
+        return data as T;
+    }
+
+    public setToken(token: string) {
+        this.token = token;
+    }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './Client';
+export * from './types';
+export * from './resources/Auth';
+export * from './resources/Threads';
+export * from './resources/Posts';
+export * from './resources/Users';
+export * from './resources/Tags';

package/src/resources/Auth.ts

@@ -0,0 +1,36 @@
+import { ForumClient } from '../Client';
+import { LoginResponse } from '../types';
+
+export class AuthResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async login(payload: { login: string; password: string; }): Promise<LoginResponse> {
+        const response = await this.client.request<LoginResponse>('/auth/login', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+
+        if (response.token) {
+            this.client.setToken(response.token);
+        }
+
+        return response;
+    }
+
+    async register(payload: import('../types').RegisterPayload): Promise<import('../types').User> {
+        return this.client.request<import('../types').User>('/auth/register', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async me(): Promise<import('../types').User> {
+        return this.client.request<import('../types').User>('/auth/me', {
+            method: 'GET',
+        });
+    }
+}

package/src/resources/Posts.ts

@@ -0,0 +1,58 @@
+import { ForumClient } from '../Client';
+import { PostListResponse, InteractionType } from '../types';
+
+export class PostsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        query?: string;
+        filter?: 'newest' | 'oldest';
+        type?: InteractionType;
+        cursor?: string;
+        userId?: string;
+    }): Promise<PostListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<PostListResponse>(`/posts?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: import('../types').CreatePostPayload): Promise<import('../types').Post> {
+        return this.client.request<import('../types').Post>('/post', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(postId: string): Promise<import('../types').Post> {
+        return this.client.request<import('../types').Post>(`/post/${postId}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(postId: string, payload: import('../types').UpdatePostPayload): Promise<import('../types').Post> {
+        return this.client.request<import('../types').Post>(`/post/${postId}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(postId: string, payload?: { userId: string }): Promise<import('../types').Post & { deleted: boolean }> {
+        return this.client.request<import('../types').Post & { deleted: boolean }>(`/post/${postId}`, {
+            method: 'DELETE',
+            body: payload ? JSON.stringify(payload) : undefined,
+        });
+    }
+}

package/src/resources/Tags.ts

@@ -0,0 +1,28 @@
+import { ForumClient } from '../Client';
+import { TagListResponse } from '../types';
+
+export class TagsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        query?: string;
+        cursor?: string;
+    }): Promise<TagListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<TagListResponse>(`/tags?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}

package/src/resources/Threads.ts

@@ -0,0 +1,59 @@
+import { ForumClient } from '../Client';
+import { ThreadListResponse, ThreadFilter, InteractionType } from '../types';
+
+export class ThreadsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        query?: string;
+        tagId?: string;
+        filter?: ThreadFilter;
+        type?: InteractionType;
+        cursor?: string;
+        userId?: string;
+    }): Promise<ThreadListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<ThreadListResponse>(`/threads?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: import('../types').CreateThreadPayload): Promise<import('../types').Thread> {
+        return this.client.request<import('../types').Thread>('/thread', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(threadId: string): Promise<import('../types').Thread> {
+        return this.client.request<import('../types').Thread>(`/thread/${threadId}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(threadId: string, payload: import('../types').UpdateThreadPayload): Promise<import('../types').Thread> {
+        return this.client.request<import('../types').Thread>(`/thread/${threadId}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(threadId: string, payload?: { userId: string }): Promise<import('../types').Thread & { deleted: boolean }> {
+        return this.client.request<import('../types').Thread & { deleted: boolean }>(`/thread/${threadId}`, {
+            method: 'DELETE',
+            body: payload ? JSON.stringify(payload) : undefined,
+        });
+    }
+}

package/src/resources/Users.ts

@@ -0,0 +1,35 @@
+import { ForumClient } from '../Client';
+import { UserListResponse, User } from '../types';
+
+export class UsersResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        query?: string;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<UserListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<UserListResponse>(`/users?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async retrieve(userId: string): Promise<User> {
+        return this.client.request<User>(`/user/${userId}`, {
+            method: 'GET',
+        });
+    }
+}

package/src/types.ts

@@ -0,0 +1,156 @@
+// Auth
+export interface RegisterPayload {
+    username: string;
+    email: string;
+    password: string;
+    displayName?: string;
+    emailVerified?: boolean;
+    roles?: string[];
+    extendedData?: Record<string, any>;
+}
+
+export interface User {
+    id: string;
+    username: string;
+    email?: string; // Optional as it might be private in some contexts
+    displayName: string | null;
+    roles?: any[]; // Refine if needed
+    extendedData?: Record<string, any>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+// Thread
+export interface Thread {
+    id: string;
+    title: string;
+    slug: string;
+    body: string;
+    userId: string;
+    locked: boolean;
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+    likes?: any[];
+    upvotes?: any[];
+    tags?: any[];
+    poll?: any;
+    extendedData?: Record<string, any>;
+    _count?: {
+        Post: number;
+        likes?: number;
+        upvotes?: number;
+    };
+}
+
+export interface CreateThreadPayload {
+    title: string;
+    body: string;
+    userId?: string; // Optional if using token
+    slug?: string;
+    locked?: boolean;
+    pinned?: boolean;
+    tags?: string[];
+    poll?: {
+        title: string;
+        options: {
+            title: string;
+            color?: string;
+            extendedData?: Record<string, any>;
+        }[];
+    };
+    extendedData?: Record<string, any>;
+}
+
+export interface UpdateThreadPayload {
+    title?: string;
+    slug?: string;
+    body?: string;
+    userId?: string;
+    locked?: boolean;
+    pinned?: boolean;
+    extendedData?: Record<string, any>;
+}
+
+// Post
+export interface Post {
+    id: string;
+    body: string;
+    threadId: string;
+    userId: string;
+    parentId?: string | null;
+    depth?: number;
+    createdAt: string;
+    updatedAt: string;
+    user?: User;
+    Thread?: {
+        userId: string;
+        title: string;
+    };
+    extendedData?: Record<string, any>;
+}
+
+export interface CreatePostPayload {
+    body: string;
+    threadId: string;
+    userId?: string; // Optional if using token
+    parentId?: string;
+    extendedData?: Record<string, any>;
+}
+
+export interface UpdatePostPayload {
+    body?: string;
+    userId?: string;
+    threadId?: string;
+    parentId?: string;
+    bestAnswer?: boolean;
+    extendedData?: Record<string, any>;
+}
+
+export interface PaginatedResponse<T> {
+    data: T[]; // Generic wrapper if API changes to this format
+}
+
+export interface ThreadListResponse {
+    threads: Thread[];
+    nextThreadCursor?: string;
+    count: number;
+}
+
+export interface PostListResponse {
+    posts: Post[];
+    nextPostCursor?: string;
+    count: number;
+}
+
+export interface LoginResponse {
+    token: string;
+}
+
+export type ThreadFilter = 'newest' | 'oldest';
+export type InteractionType = 'created' | 'liked' | 'disliked' | 'upvoted' | 'downvoted' | 'subscribed';
+
+export interface Tag {
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        threads: number;
+    };
+    threads?: Thread[];
+}
+
+export interface UserListResponse {
+    users: User[];
+    nextUserCursor?: string;
+    count: number;
+}
+
+export interface TagListResponse {
+    tags: Tag[];
+    nextTagCursor?: string;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target": "es2019",
+        "module": "commonjs",
+        "declaration": true,
+        "outDir": "./dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "types": [
+            "node"
+        ]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "../node_modules"
+    ]
+}