@foru-ms/sdk 0.1.0 → 1.1.0

package/dist/resources/Reports.d.ts

@@ -0,0 +1,46 @@
+import { ForumClient } from '../Client';
+import { Report, ReportListResponse } from '../types';
+export declare class ReportsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        reporterId?: string;
+        reportedId?: string;
+        read?: boolean;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<ReportListResponse>;
+    create(payload: {
+        reporterId: string;
+        reportedId?: string;
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        type?: string;
+        description?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Report>;
+    batchUpdate(payload: {
+        reportIds: string[];
+        read: boolean;
+    }): Promise<{
+        count?: number;
+        message?: string;
+    }>;
+    retrieve(id: string): Promise<Report>;
+    update(id: string, payload: {
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        reportedId?: string;
+        reporterId?: string;
+        type?: string;
+        description?: string;
+        read?: boolean;
+        extendedData?: Record<string, any>;
+    }): Promise<Report>;
+    delete(id: string): Promise<Report & {
+        deleted: boolean;
+    }>;
+    updateStatus(id: string, read: boolean): Promise<Report>;
+}

package/dist/resources/Reports.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportsResource = void 0;
+class ReportsResource {
+    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, String(value));
+                }
+            });
+        }
+        return this.client.request(`/reports?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/report', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async batchUpdate(payload) {
+        return this.client.request('/reports', {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/report/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/report/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/report/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async updateStatus(id, read) {
+        return this.client.request(`/report/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ read }),
+        });
+    }
+}
+exports.ReportsResource = ReportsResource;

package/dist/resources/Roles.d.ts

@@ -0,0 +1,26 @@
+import { ForumClient } from '../Client';
+import { Role, RoleListResponse } from '../types';
+export declare class RolesResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<RoleListResponse>;
+    create(payload: {
+        name: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Role>;
+    retrieve(id: string): Promise<Role>;
+    update(id: string, payload: {
+        name?: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Role>;
+    delete(id: string): Promise<Role & {
+        deleted: boolean;
+    }>;
+}

package/dist/resources/Roles.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolesResource = void 0;
+class RolesResource {
+    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(`/roles?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/role', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/role/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/role/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/role/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}
+exports.RolesResource = RolesResource;

package/dist/resources/SSO.d.ts

@@ -0,0 +1,17 @@
+import { ForumClient } from '../Client';
+import { SSOProvider, SSOProviderListResponse } from '../types';
+export declare class SSOResource {
+    private client;
+    constructor(client: ForumClient);
+    list(): Promise<SSOProviderListResponse>;
+    create(payload: {
+        provider: 'OKTA' | 'AUTH0' | 'SAML';
+        domain: string;
+        config: any;
+    }): Promise<{
+        ssoProvider: SSOProvider;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/resources/SSO.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSOResource = void 0;
+class SSOResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        return this.client.request('/sso', {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/sso', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/sso/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}
+exports.SSOResource = SSOResource;

package/dist/resources/Search.d.ts

@@ -0,0 +1,11 @@
+import { ForumClient } from '../Client';
+import { SearchResponse } from '../types';
+export declare class SearchResource {
+    private client;
+    constructor(client: ForumClient);
+    search(params: {
+        query: string;
+        type: 'threads' | 'posts' | 'users' | 'tags';
+        cursor?: string;
+    }): Promise<SearchResponse>;
+}

package/dist/resources/Search.js

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

package/dist/resources/Stats.d.ts

@@ -0,0 +1,13 @@
+import { ForumClient } from '../Client';
+import { StatsResponse } from '../types';
+export declare class StatsResource {
+    private client;
+    constructor(client: ForumClient);
+    get(params?: {
+        filter?: 'newest' | 'oldest';
+        threadCursor?: string;
+        postCursor?: string;
+        userCursor?: string;
+        reportCursor?: string;
+    }): Promise<StatsResponse>;
+}

package/dist/resources/Stats.js

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

package/dist/resources/Tags.d.ts

@@ -7,4 +7,31 @@ export declare class TagsResource {
         query?: string;
         cursor?: string;
     }): Promise<TagListResponse>;
+    create(payload: {
+        name: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<import('../types').Tag>;
+    retrieve(id: string, params?: {
+        userId?: string;
+    }): Promise<import('../types').Tag & {
+        isSubscribed?: boolean;
+    }>;
+    update(id: string, payload: {
+        name?: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<import('../types').Tag>;
+    delete(id: string): Promise<import('../types').Tag & {
+        deleted: boolean;
+    }>;
+    subscribe(id: string, userId: string): Promise<any>;
+    unsubscribe(id: string, userId: string): Promise<any>;
+    listSubscribed(params: {
+        userId: string;
+        query?: string;
+        cursor?: string;
+    }): Promise<TagListResponse>;
 }

package/dist/resources/Tags.js

@@ -18,5 +18,52 @@ class TagsResource {
             method: 'GET',
         });
     }
+    async create(payload) {
+        return this.client.request('/tag', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params === null || params === void 0 ? void 0 : params.userId)
+            searchParams.append('userId', params.userId);
+        return this.client.request(`/tag/${id}?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/tag/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/tag/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async subscribe(id, userId) {
+        return this.client.request(`/tag/${id}/subscribers`, {
+            method: 'POST',
+            body: JSON.stringify({ userId }),
+        });
+    }
+    async unsubscribe(id, userId) {
+        return this.client.request(`/tag/${id}/subscribers?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async listSubscribed(params) {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                searchParams.append(key, value);
+            }
+        });
+        return this.client.request(`/tags/subscribed?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
 }
 exports.TagsResource = TagsResource;

package/dist/resources/Threads.d.ts

@@ -19,4 +19,18 @@ export declare class ThreadsResource {
     }): Promise<import('../types').Thread & {
         deleted: boolean;
     }>;
+    getPosts(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<any>;
+    like(id: string, userId?: string, extendedData?: any): Promise<any>;
+    unlike(id: string, userId: string): Promise<any>;
+    dislike(id: string, userId?: string, extendedData?: any): Promise<any>;
+    undislike(id: string, userId: string): Promise<any>;
+    subscribe(id: string, userId: string, extendedData?: any): Promise<any>;
+    unsubscribe(id: string, userId: string): Promise<any>;
+    vote(id: string, optionId: string, userId: string): Promise<any>;
+    voteUpdate(id: string, optionId: string, userId: string): Promise<any>;
+    unvote(id: string, userId: string): Promise<any>;
 }

package/dist/resources/Threads.js

@@ -41,5 +41,66 @@ class ThreadsResource {
             body: payload ? JSON.stringify(payload) : undefined,
         });
     }
+    async getPosts(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/thread/${id}/posts?${searchParams.toString()}`, { method: 'GET' });
+    }
+    async like(id, userId, extendedData) {
+        return this.client.request(`/thread/${id}/likes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async unlike(id, userId) {
+        return this.client.request(`/thread/${id}/likes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async dislike(id, userId, extendedData) {
+        return this.client.request(`/thread/${id}/dislikes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async undislike(id, userId) {
+        return this.client.request(`/thread/${id}/dislikes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async subscribe(id, userId, extendedData) {
+        return this.client.request(`/thread/${id}/subscribers`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async unsubscribe(id, userId) {
+        return this.client.request(`/thread/${id}/subscribers?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async vote(id, optionId, userId) {
+        return this.client.request(`/thread/${id}/poll/votes`, {
+            method: 'POST',
+            body: JSON.stringify({ optionId, userId }),
+        });
+    }
+    async voteUpdate(id, optionId, userId) {
+        return this.client.request(`/thread/${id}/poll/votes`, {
+            method: 'PUT',
+            body: JSON.stringify({ optionId, userId }),
+        });
+    }
+    async unvote(id, userId) {
+        return this.client.request(`/thread/${id}/poll/votes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
 }
 exports.ThreadsResource = ThreadsResource;

package/dist/resources/Users.d.ts

@@ -9,4 +9,51 @@ export declare class UsersResource {
         cursor?: string;
     }): Promise<UserListResponse>;
     retrieve(userId: string): Promise<User>;
+    create(payload: {
+        username: string;
+        email: string;
+        password: string;
+        displayName?: string;
+        emailVerified?: boolean;
+        roles?: string[];
+        bio?: string;
+        signature?: string;
+        url?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<User>;
+    update(id: string, payload: {
+        username?: string;
+        email?: string;
+        password?: string;
+        displayName?: string;
+        emailVerified?: boolean;
+        roles?: string[];
+        bio?: string;
+        signature?: string;
+        url?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<User>;
+    delete(id: string): Promise<User & {
+        deleted: boolean;
+    }>;
+    getFollowers(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<{
+        followers: User[];
+        nextUserCursor?: string;
+        count: number;
+    }>;
+    follow(id: string, followerId: string, extendedData?: any): Promise<any>;
+    unfollow(id: string, followerId: string): Promise<any>;
+    getFollowing(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<{
+        following: any[];
+        nextUserCursor?: string;
+        count: number;
+    }>;
 }

package/dist/resources/Users.js

@@ -23,5 +23,59 @@ class UsersResource {
             method: 'GET',
         });
     }
+    async create(payload) {
+        return this.client.request('/user', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/user/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/user/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async getFollowers(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/user/${id}/followers?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async follow(id, followerId, extendedData) {
+        return this.client.request(`/user/${id}/followers`, {
+            method: 'POST',
+            body: JSON.stringify({ followerId, extendedData }),
+        });
+    }
+    async unfollow(id, followerId) {
+        return this.client.request(`/user/${id}/followers?followerId=${followerId}`, {
+            method: 'DELETE',
+        });
+    }
+    async getFollowing(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/user/${id}/following?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
 }
 exports.UsersResource = UsersResource;

package/dist/resources/Webhooks.d.ts

@@ -0,0 +1,35 @@
+import { ForumClient } from '../Client';
+import { Webhook, WebhookListResponse } from '../types';
+export declare class WebhooksResource {
+    private client;
+    constructor(client: ForumClient);
+    list(): Promise<WebhookListResponse>;
+    create(payload: {
+        name: string;
+        url: string;
+        events: string[];
+    }): Promise<{
+        webhook: Webhook;
+    }>;
+    retrieve(id: string): Promise<{
+        webhook: Webhook;
+    }>;
+    update(id: string, payload: {
+        name?: string;
+        url?: string;
+        events?: string[];
+        active?: boolean;
+    }): Promise<{
+        webhook: Webhook;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    getDeliveries(id: string, params?: {
+        cursor?: string;
+    }): Promise<{
+        deliveries: any[];
+        total: number;
+        nextCursor?: string;
+    }>;
+}

package/dist/resources/Webhooks.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksResource = void 0;
+class WebhooksResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        return this.client.request('/webhooks', {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/webhooks', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/webhooks/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/webhooks/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/webhooks/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async getDeliveries(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params === null || params === void 0 ? void 0 : params.cursor)
+            searchParams.append('cursor', params.cursor);
+        return this.client.request(`/webhooks/${id}/deliveries?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}
+exports.WebhooksResource = WebhooksResource;