@addn/sdk 1.0.0

package/src/modules/customers.module.ts

@@ -0,0 +1,48 @@
+import { HttpClient } from "../http/http-client";
+import type { Customer, CreateCustomerPayload, UpdateCustomerPayload } from "../types";
+
+export class CustomersModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async listCustomers(orgId?: string): Promise<Customer[]> {
+    return await this.http.request<Customer[]>({
+      path: "/api/v1/customers",
+      method: "GET",
+      query: orgId ? { org_id: orgId } : undefined,
+    });
+  }
+
+  public async getCustomer(customerId: string): Promise<Customer> {
+    return await this.http.request<Customer>({
+      path: `/api/v1/customers/${customerId}`,
+      method: "GET",
+    });
+  }
+
+  public async createCustomer(payload: CreateCustomerPayload): Promise<Customer> {
+    return await this.http.request<Customer>({
+      path: "/api/v1/customers",
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  public async updateCustomer(customerId: string, payload: UpdateCustomerPayload): Promise<Customer> {
+    return await this.http.request<Customer>({
+      path: `/api/v1/customers/${customerId}`,
+      method: "PATCH",
+      body: payload,
+    });
+  }
+
+  public async deleteCustomer(customerId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/customers/${customerId}`,
+      method: "DELETE",
+    });
+  }
+}

package/src/modules/notifications.module.ts

@@ -0,0 +1,41 @@
+import { HttpClient } from "../http/http-client";
+import type { NotificationItem, NotificationListResponse } from "../types";
+
+export class NotificationsModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async getNotifications(params?: { unread_only?: boolean; limit?: number; offset?: number }): Promise<NotificationListResponse> {
+    return await this.http.request<NotificationListResponse>({
+      path: "/api/v1/notifications",
+      method: "GET",
+      query: params,
+    });
+  }
+
+  public async markAsRead(notificationIds?: string[]): Promise<{ success: boolean; marked_count: number }> {
+    return await this.http.request<{ success: boolean; marked_count: number }>({
+      path: "/api/v1/notifications/read",
+      method: "PATCH",
+      query: notificationIds ? { notification_ids: notificationIds } : undefined,
+    });
+  }
+
+  public async deleteNotification(notificationId: string): Promise<{ deleted: boolean }> {
+    return await this.http.request<{ deleted: boolean }>({
+      path: `/api/v1/notifications/${notificationId}`,
+      method: "DELETE",
+    });
+  }
+
+  public async registerPushToken(token: string, platform: "web" | "ios" | "android"): Promise<void> {
+    await this.http.request({
+      path: "/api/v1/notifications/push-token",
+      method: "POST",
+      body: { push_token: token, platform },
+    });
+  }
+}

package/src/modules/orgs.module.ts

@@ -0,0 +1,122 @@
+import { HttpClient } from "../http/http-client";
+import type { Organization, OrganizationMember, CreateOrgPayload, InviteMemberPayload, OrgJoinRequest } from "../types";
+
+export class OrgsModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async getMyOrganizations(): Promise<Organization[]> {
+    return await this.http.request<Organization[]>({
+      path: "/api/v1/orgs",
+      method: "GET",
+    });
+  }
+
+  public async getOrganization(orgId: string): Promise<Organization> {
+    return await this.http.request<Organization>({
+      path: `/api/v1/orgs/${orgId}`,
+      method: "GET",
+    });
+  }
+
+  public async createOrganization(payload: CreateOrgPayload): Promise<Organization> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/org/create",
+      method: "POST",
+      body: payload,
+    });
+    return res?.organization || res;
+  }
+
+  public async joinOrganization(code: string): Promise<OrgJoinRequest> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/org/join",
+      method: "POST",
+      body: { code },
+    });
+    return res?.request || res;
+  }
+
+  public async getMyJoinRequest(): Promise<OrgJoinRequest | null> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/org/my-join-request",
+      method: "GET",
+    });
+    return res?.request || res || null;
+  }
+
+  public async cancelJoinRequest(): Promise<void> {
+    await this.http.request({
+      path: "/api/v1/org/my-join-request",
+      method: "DELETE",
+    });
+  }
+
+  public async listJoinRequests(): Promise<OrgJoinRequest[]> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/org/join-requests",
+      method: "GET",
+    });
+    if (Array.isArray(res)) return res;
+    if (Array.isArray(res?.requests)) return res.requests;
+    return [];
+  }
+
+  public async approveJoinRequest(requestId: string, designation: string = "Team Member"): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/org/join-requests/${requestId}/approve`,
+      method: "POST",
+      body: { designation },
+    });
+  }
+
+  public async rejectJoinRequest(requestId: string, reason: string = "Declined"): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/org/join-requests/${requestId}/reject`,
+      method: "POST",
+      body: { reason },
+    });
+  }
+
+  public async getMembers(): Promise<OrganizationMember[]> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/org/members",
+      method: "GET",
+    });
+    if (Array.isArray(res)) return res;
+    if (Array.isArray(res?.members)) return res.members;
+    return [];
+  }
+
+  public async inviteMember(orgId: string, payload: InviteMemberPayload): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/orgs/${orgId}/invite`,
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  public async removeMember(orgId: string, userId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/orgs/${orgId}/members/${userId}`,
+      method: "DELETE",
+    });
+  }
+
+  public async kickMember(memberId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/org/members/${memberId}/kick`,
+      method: "POST",
+    });
+  }
+
+  public async rotateCode(): Promise<{ code: string }> {
+    return await this.http.request<{ code: string }>({
+      path: "/api/v1/org/rotate-code",
+      method: "POST",
+    });
+  }
+}

package/src/modules/projects.module.ts

@@ -0,0 +1,97 @@
+import { HttpClient } from "../http/http-client";
+import type { Project, CreateProjectPayload, UpdateProjectPayload, ProjectMember, ProjectAccount } from "../types";
+
+export class ProjectsModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async listProjects(params?: { org_id?: string; customer_id?: string; status?: string }): Promise<Project[]> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/projects",
+      method: "GET",
+      query: params,
+    });
+    if (Array.isArray(res)) return res;
+    if (res?.projects && Array.isArray(res.projects)) return res.projects;
+    return [];
+  }
+
+  public async getProject(projectId: string): Promise<{ project: Project; members: ProjectMember[]; accounts: ProjectAccount[] }> {
+    return await this.http.request({
+      path: `/api/v1/projects/${projectId}`,
+      method: "GET",
+    });
+  }
+
+  public async createProject(payload: CreateProjectPayload): Promise<Project> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/projects",
+      method: "POST",
+      body: payload,
+    });
+    return res?.project || res;
+  }
+
+  public async updateProject(projectId: string, payload: UpdateProjectPayload): Promise<Project> {
+    const res = await this.http.request<any>({
+      path: `/api/v1/projects/${projectId}`,
+      method: "PATCH",
+      body: payload,
+    });
+    return res?.project || res;
+  }
+
+  public async archiveProject(projectId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/archive`,
+      method: "POST",
+    });
+  }
+
+  public async restoreProject(projectId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/restore`,
+      method: "POST",
+    });
+  }
+
+  public async deleteProject(projectId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}`,
+      method: "DELETE",
+    });
+  }
+
+  public async assignMember(projectId: string, userId: string, role: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/members`,
+      method: "POST",
+      body: { user_id: userId, role },
+    });
+  }
+
+  public async removeMember(projectId: string, userId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/members/${userId}`,
+      method: "DELETE",
+    });
+  }
+
+  public async assignAccount(projectId: string, accountId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/accounts`,
+      method: "POST",
+      body: { account_id: accountId },
+    });
+  }
+
+  public async removeAccount(projectId: string, accountId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/projects/${projectId}/accounts/${accountId}`,
+      method: "DELETE",
+    });
+  }
+}

package/src/modules/scheduling.module.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from "../http/http-client";
+import type { ScheduledPost, PublicApprovalView, SubmitApprovalPayload } from "../types";
+
+export class SchedulingModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async getScheduledPosts(params?: { project_id?: string; month?: string }): Promise<ScheduledPost[]> {
+    return await this.http.request<ScheduledPost[]>({
+      path: "/api/v1/scheduling",
+      method: "GET",
+      query: params,
+    });
+  }
+
+  public async getPublicApprovalView(token: string): Promise<PublicApprovalView> {
+    return await this.http.request<PublicApprovalView>({
+      path: `/approval/${token}`,
+      method: "GET",
+      requiresAuth: false,
+    });
+  }
+
+  public async submitPublicApproval(payload: SubmitApprovalPayload): Promise<void> {
+    await this.http.request({
+      path: `/approval/${payload.token}/action`,
+      method: "POST",
+      body: payload,
+      requiresAuth: false,
+    });
+  }
+}

package/src/modules/storage.module.ts

@@ -0,0 +1,121 @@
+import { HttpClient } from "../http/http-client";
+import type { MediaAsset, PresignedUploadResponse, UploadFileResponse } from "../types";
+
+export class StorageModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async requestPresignedUpload(payload: {
+    filename: string;
+    content_type: string;
+    file_size: number;
+    project_id?: string;
+  }): Promise<PresignedUploadResponse> {
+    const res = await this.http.request<any>({
+      path: "/api/v1/storage/presign-upload",
+      method: "POST",
+      body: payload,
+    });
+    const data = res?.data || res;
+    const uploadUrl = data?.upload_url || data?.presigned_url || data?.uploadUrl || "";
+    const downloadUrl = data?.download_url || data?.url || data?.downloadUrl || "";
+    const assetId = data?.asset_id || data?.assetId || "";
+    const storagePath = data?.storage_path || data?.storagePath || "";
+
+    return {
+      upload_url: uploadUrl,
+      presigned_url: uploadUrl,
+      asset_id: assetId,
+      storage_path: storagePath,
+      download_url: downloadUrl,
+      url: downloadUrl,
+    };
+  }
+
+  public async uploadBinaryFile(
+    presignedUrl: string,
+    file: File,
+    onProgress?: (percent: number) => void
+  ): Promise<void> {
+    if (!presignedUrl || typeof presignedUrl !== "string" || !presignedUrl.startsWith("http")) {
+      throw new Error(`Invalid upload URL: "${presignedUrl}". Could not initialize file upload.`);
+    }
+
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("PUT", presignedUrl, true);
+      xhr.setRequestHeader("Content-Type", file.type || "application/octet-stream");
+      xhr.upload.onprogress = (event) => {
+        if (event.lengthComputable && onProgress && event.total > 0) {
+          onProgress(Math.round((event.loaded / event.total) * 100));
+        }
+      };
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve();
+        } else {
+          try {
+            const err = JSON.parse(xhr.responseText);
+            reject(new Error(err.message || err.detail || `Upload failed with status ${xhr.status}`));
+          } catch {
+            reject(new Error(`Upload failed with status ${xhr.status}`));
+          }
+        }
+      };
+      xhr.onerror = () => reject(new Error("Network error during file upload"));
+      xhr.send(file);
+    });
+  }
+
+  public async uploadFile(fileInput: File | Blob | FormData | { uri: string; name: string; type: string }): Promise<UploadFileResponse> {
+    let formData: FormData;
+
+    if (fileInput instanceof FormData) {
+      formData = fileInput;
+    } else {
+      formData = new FormData();
+      if ("uri" in fileInput) {
+        formData.append("file", fileInput as any);
+      } else {
+        formData.append("file", fileInput, (fileInput as File).name || "upload");
+      }
+    }
+
+    return await this.http.request<UploadFileResponse>({
+      path: "/api/v1/storage/upload",
+      method: "POST",
+      formData,
+    });
+  }
+
+  public async listAssets(params?: {
+    project_id?: string;
+    media_type?: string;
+    search?: string;
+    page?: number;
+    page_size?: number;
+  }): Promise<{ assets: MediaAsset[]; total: number; page: number; page_size: number }> {
+    return await this.http.request({
+      path: "/api/v1/storage/assets",
+      method: "GET",
+      query: params,
+    });
+  }
+
+  public async getUploadStatus(assetId: string): Promise<{ status: string; url?: string }> {
+    return await this.http.request<{ status: string; url?: string }>({
+      path: `/api/v1/storage/uploads/${assetId}/status`,
+      method: "GET",
+    });
+  }
+
+  public async deleteAsset(assetId: string): Promise<void> {
+    await this.http.request({
+      path: `/api/v1/storage/assets/${assetId}`,
+      method: "DELETE",
+    });
+  }
+}

package/src/modules/subscriptions.module.ts

@@ -0,0 +1,82 @@
+import { HttpClient } from "../http/http-client";
+import type {
+  SubscriptionPlan,
+  CurrentSubscription,
+  QuotaStatus,
+  RazorpayCreateResult,
+  RazorpayVerifyResult,
+} from "../types";
+
+export class SubscriptionsModule {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  public async getPlans(): Promise<SubscriptionPlan[]> {
+    return await this.http.request<SubscriptionPlan[]>({
+      path: "/api/v1/subscriptions/plans",
+      method: "GET",
+      requiresAuth: false,
+    });
+  }
+
+  public async getCurrentSubscription(): Promise<CurrentSubscription> {
+    return await this.http.request<CurrentSubscription>({
+      path: "/api/v1/subscriptions/current",
+      method: "GET",
+    });
+  }
+
+  public async getQuotaStatus(): Promise<QuotaStatus> {
+    return await this.http.request<QuotaStatus>({
+      path: "/api/v1/subscriptions/quota-status",
+      method: "GET",
+    });
+  }
+
+  public async cancelSubscription(): Promise<any> {
+    return await this.http.request({
+      path: "/api/v1/subscriptions/cancel",
+      method: "POST",
+    });
+  }
+
+  public async reactivateSubscription(): Promise<any> {
+    return await this.http.request({
+      path: "/api/v1/subscriptions/reactivate",
+      method: "POST",
+    });
+  }
+
+  public async createRazorpayOrder(planId: string): Promise<RazorpayCreateResult> {
+    return await this.http.request<RazorpayCreateResult>({
+      path: "/api/v1/subscriptions/razorpay/create",
+      method: "POST",
+      body: { plan_id: planId },
+    });
+  }
+
+  public async verifyRazorpayPayment(payload: {
+    razorpay_order_id?: string;
+    razorpay_payment_id?: string;
+    razorpay_signature?: string;
+    plan_id?: string;
+    razorpay_subscription_id?: string;
+  }): Promise<RazorpayVerifyResult> {
+    return await this.http.request<RazorpayVerifyResult>({
+      path: "/api/v1/subscriptions/razorpay/verify",
+      method: "POST",
+      body: payload,
+    });
+  }
+
+  public async verifyGooglePlayPurchase(payload: { package_name: string; product_id: string; purchase_token: string }): Promise<any> {
+    return await this.http.request({
+      path: "/api/v1/subscriptions/google-play/verify",
+      method: "POST",
+      body: payload,
+    });
+  }
+}

package/src/types/account.types.ts

@@ -0,0 +1,17 @@
+export interface ConnectedAccount {
+  id: string;
+  organization_id: string;
+  platform: "instagram" | "facebook" | "linkedin";
+  account_name: string;
+  account_id: string;
+  username?: string;
+  profile_picture_url?: string;
+  is_active: boolean;
+  connected_at: string;
+}
+
+export interface ConnectAccountPayload {
+  platform: "instagram" | "facebook" | "linkedin";
+  auth_code: string;
+  redirect_uri: string;
+}

package/src/types/analytics.types.ts

@@ -0,0 +1,15 @@
+export interface AnalyticsMetric {
+  date: string;
+  reach: number;
+  impressions: number;
+  engagement: number;
+  followers_gained: number;
+}
+
+export interface AnalyticsSummary {
+  total_posts: number;
+  total_reach: number;
+  total_engagement: number;
+  average_engagement_rate: number;
+  metrics: AnalyticsMetric[];
+}

package/src/types/api.types.ts

@@ -0,0 +1,21 @@
+export interface ApiResponse<T = any> {
+  success: boolean;
+  message?: string;
+  data: T;
+  code?: string;
+  details?: any;
+}
+
+export interface PaginatedMeta {
+  total: number;
+  page: number;
+  limit: number;
+  pages: number;
+}
+
+export interface PaginatedResponse<T = any> {
+  success: boolean;
+  message?: string;
+  data: T[];
+  meta: PaginatedMeta;
+}

package/src/types/auth.types.ts

@@ -0,0 +1,45 @@
+export interface UserProfile {
+  id: string;
+  email: string;
+  full_name: string;
+  role: "admin" | "org_admin" | "member" | "viewer" | string;
+  organization_id?: string | null;
+  avatar_url?: string | null;
+  is_active: boolean;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface LoginPayload {
+  email: string;
+  password: string;
+}
+
+export interface RegisterPayload {
+  email: string;
+  password: string;
+  full_name: string;
+  organization_name?: string;
+}
+
+export interface AuthTokenResponse {
+  access_token: string;
+  refresh_token: string;
+  token_type: string;
+  expires_in?: number;
+  user: UserProfile;
+}
+
+export interface PasswordResetRequestPayload {
+  email: string;
+}
+
+export interface PasswordResetConfirmPayload {
+  token: string;
+  new_password: string;
+}
+
+export interface MetaLoginPayload {
+  code: string;
+  redirect_uri: string;
+}

package/src/types/content-plan.types.ts

@@ -0,0 +1,28 @@
+export interface PostItem {
+  id: string;
+  title: string;
+  caption?: string;
+  media_urls?: string[];
+  post_type: "reel" | "carousel" | "single_image" | "story";
+  scheduled_at?: string;
+  status: "draft" | "pending_approval" | "approved" | "rejected" | "published";
+  rejection_reason?: string;
+}
+
+export interface ContentPlan {
+  id: string;
+  project_id: string;
+  title: string;
+  month: string;
+  status: "draft" | "in_review" | "approved" | "published";
+  posts: PostItem[];
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CreateContentPlanPayload {
+  project_id: string;
+  title: string;
+  month: string;
+  posts?: Partial<PostItem>[];
+}