@b3dotfun/sdk 0.1.68 → 0.1.69-alpha.0

package/src/anyspend/platform/resources/customers.ts

@@ -0,0 +1,54 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type {
+  Customer,
+  Transaction,
+  ListResponse,
+  DeletedResponse,
+  CreateCustomerParams,
+  UpdateCustomerParams,
+  ExportCustomersParams,
+  PaginationParams,
+} from "../types";
+
+export interface ListCustomersParams extends PaginationParams {
+  search?: string;
+  sort?: "created_at" | "updated_at" | "total_paid" | "transaction_count";
+  order?: "asc" | "desc";
+}
+
+export class CustomersResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListCustomersParams): Promise<ListResponse<Customer>> {
+    return this.client.get<ListResponse<Customer>>("/customers", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListCustomersParams, "page">): AsyncGenerator<Customer> {
+    yield* autoPaginate<Customer>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async create(params: CreateCustomerParams): Promise<Customer> {
+    return this.client.post<Customer>("/customers", params);
+  }
+
+  async get(id: string): Promise<Customer> {
+    return this.client.get<Customer>(`/customers/${id}`);
+  }
+
+  async update(id: string, params: UpdateCustomerParams): Promise<Customer> {
+    return this.client.patch<Customer>(`/customers/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/customers/${id}`);
+  }
+
+  async transactions(id: string, params?: PaginationParams): Promise<ListResponse<Transaction>> {
+    return this.client.get<ListResponse<Transaction>>(`/customers/${id}/transactions`, params);
+  }
+
+  async export(params?: ExportCustomersParams): Promise<string> {
+    return this.client.get<string>("/customers/export", params);
+  }
+}

package/src/anyspend/platform/resources/discount-codes.ts

@@ -0,0 +1,63 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type {
+  DiscountCode,
+  ListResponse,
+  DeletedResponse,
+  CreateDiscountCodeParams,
+  BatchCreateDiscountCodesParams,
+  ValidateDiscountResult,
+  BatchCreateResult,
+  PaginationParams,
+} from "../types";
+
+export interface ListDiscountCodesParams extends PaginationParams {
+  payment_link_id?: string;
+  active?: "true" | "false";
+  search?: string;
+}
+
+export interface UpdateDiscountCodeParams {
+  is_active?: boolean;
+  max_uses?: number;
+  min_order_amount?: string;
+  expires_at?: number;
+}
+
+export interface ValidateDiscountParams {
+  code: string;
+  payment_link_id?: string;
+  amount?: string;
+}
+
+export class DiscountCodesResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListDiscountCodesParams): Promise<ListResponse<DiscountCode>> {
+    return this.client.get<ListResponse<DiscountCode>>("/discount-codes", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListDiscountCodesParams, "page">): AsyncGenerator<DiscountCode> {
+    yield* autoPaginate<DiscountCode>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async create(params: CreateDiscountCodeParams): Promise<DiscountCode> {
+    return this.client.post<DiscountCode>("/discount-codes", params);
+  }
+
+  async update(id: string, params: UpdateDiscountCodeParams): Promise<DiscountCode> {
+    return this.client.patch<DiscountCode>(`/discount-codes/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/discount-codes/${id}`);
+  }
+
+  async validate(params: ValidateDiscountParams): Promise<ValidateDiscountResult> {
+    return this.client.post<ValidateDiscountResult>("/discount-codes/validate", params);
+  }
+
+  async batchCreate(params: BatchCreateDiscountCodesParams): Promise<BatchCreateResult> {
+    return this.client.post<BatchCreateResult>("/discount-codes/batch", params);
+  }
+}

package/src/anyspend/platform/resources/events.ts

@@ -0,0 +1,22 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type { ApiEvent, ListResponse, PaginationParams } from "../types";
+
+export interface ListEventsParams extends PaginationParams {
+  event_type?: string;
+  resource_type?: string;
+  from?: number;
+  to?: number;
+}
+
+export class EventsResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListEventsParams): Promise<ListResponse<ApiEvent>> {
+    return this.client.get<ListResponse<ApiEvent>>("/events", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListEventsParams, "page">): AsyncGenerator<ApiEvent> {
+    yield* autoPaginate<ApiEvent>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+}

package/src/anyspend/platform/resources/notifications.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "../client";
+import type { NotificationSettings, UpdateNotificationSettingsParams, ActionResponse } from "../types";
+
+export interface TelegramLinkResult {
+  object: "telegram_link";
+  link_url: string;
+  link_code: string;
+  expires_at: number;
+}
+
+export class NotificationsResource {
+  constructor(private client: HttpClient) {}
+
+  async get(): Promise<NotificationSettings> {
+    return this.client.get<NotificationSettings>("/notifications");
+  }
+
+  async update(params: UpdateNotificationSettingsParams): Promise<NotificationSettings> {
+    return this.client.patch<NotificationSettings>("/notifications", params);
+  }
+
+  async linkTelegram(): Promise<TelegramLinkResult> {
+    return this.client.post<TelegramLinkResult>("/notifications/telegram/link");
+  }
+
+  async unlinkTelegram(): Promise<ActionResponse> {
+    return this.client.post<ActionResponse>("/notifications/telegram/unlink");
+  }
+
+  async testEmail(): Promise<ActionResponse> {
+    return this.client.post<ActionResponse>("/notifications/test/email");
+  }
+
+  async testTelegram(): Promise<ActionResponse> {
+    return this.client.post<ActionResponse>("/notifications/test/telegram");
+  }
+}

package/src/anyspend/platform/resources/organization.ts

@@ -0,0 +1,24 @@
+import type { HttpClient } from "../client";
+import type { Organization } from "../types";
+
+export interface UpdateOrganizationParams {
+  name?: string;
+  description?: string;
+  logo_url?: string;
+  website_url?: string;
+  default_recipient_address?: string;
+  default_chain_id?: number;
+  default_token_address?: string;
+}
+
+export class OrganizationResource {
+  constructor(private client: HttpClient) {}
+
+  async get(): Promise<Organization> {
+    return this.client.get<Organization>("/organization");
+  }
+
+  async update(params: UpdateOrganizationParams): Promise<Organization> {
+    return this.client.patch<Organization>("/organization", params);
+  }
+}

package/src/anyspend/platform/resources/payment-links.ts

@@ -0,0 +1,74 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type {
+  PaymentLink,
+  PaymentLinkItem,
+  PaymentLinkStats,
+  CheckoutSession,
+  ListResponse,
+  DeletedResponse,
+  CreatePaymentLinkParams,
+  CreatePaymentLinkItemParams,
+  UpdatePaymentLinkParams,
+  ListPaymentLinksParams,
+  PaginationParams,
+} from "../types";
+
+export class PaymentLinksResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListPaymentLinksParams): Promise<ListResponse<PaymentLink>> {
+    return this.client.get<ListResponse<PaymentLink>>("/payment-links", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListPaymentLinksParams, "page">): AsyncGenerator<PaymentLink> {
+    yield* autoPaginate<PaymentLink>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async create(params: CreatePaymentLinkParams): Promise<PaymentLink> {
+    return this.client.post<PaymentLink>("/payment-links", params);
+  }
+
+  async get(id: string): Promise<PaymentLink> {
+    return this.client.get<PaymentLink>(`/payment-links/${id}`);
+  }
+
+  async update(id: string, params: UpdatePaymentLinkParams): Promise<PaymentLink> {
+    return this.client.patch<PaymentLink>(`/payment-links/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/payment-links/${id}`);
+  }
+
+  async duplicate(id: string, overrides?: Partial<CreatePaymentLinkParams>): Promise<PaymentLink> {
+    return this.client.post<PaymentLink>(`/payment-links/${id}/duplicate`, overrides ?? {});
+  }
+
+  async stats(id: string, days?: number): Promise<PaymentLinkStats> {
+    return this.client.get<PaymentLinkStats>(`/payment-links/${id}/stats`, days !== undefined ? { days } : undefined);
+  }
+
+  async sessions(id: string, params?: PaginationParams): Promise<ListResponse<CheckoutSession>> {
+    return this.client.get<ListResponse<CheckoutSession>>(`/payment-links/${id}/sessions`, params);
+  }
+
+  async visitors(
+    id: string,
+    params?: PaginationParams & { days?: number },
+  ): Promise<ListResponse<Record<string, unknown>>> {
+    return this.client.get<ListResponse<Record<string, unknown>>>(`/payment-links/${id}/visitors`, params);
+  }
+
+  async items(id: string): Promise<PaymentLinkItem[]> {
+    return this.client.get<PaymentLinkItem[]>(`/payment-links/${id}/items`);
+  }
+
+  async addItem(id: string, item: CreatePaymentLinkItemParams): Promise<PaymentLinkItem> {
+    return this.client.post<PaymentLinkItem>(`/payment-links/${id}/items`, item);
+  }
+
+  async removeItem(id: string, itemId: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/payment-links/${id}/items/${itemId}`);
+  }
+}

package/src/anyspend/platform/resources/products.ts

@@ -0,0 +1,59 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type {
+  Product,
+  PaymentLink,
+  ListResponse,
+  DeletedResponse,
+  CreateProductParams,
+  UpdateProductParams,
+  PaginationParams,
+} from "../types";
+
+export interface ListProductsParams extends PaginationParams {
+  search?: string;
+  active?: "true" | "false";
+  product_type?: "one_time" | "subscription" | "variable";
+  sort?: "created_at" | "updated_at" | "name";
+  order?: "asc" | "desc";
+}
+
+export interface GenerateLinkParams {
+  recipient_address?: string;
+  name?: string;
+  description?: string;
+  theme_color?: string;
+  button_text?: string;
+}
+
+export class ProductsResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListProductsParams): Promise<ListResponse<Product>> {
+    return this.client.get<ListResponse<Product>>("/products", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListProductsParams, "page">): AsyncGenerator<Product> {
+    yield* autoPaginate<Product>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async create(params: CreateProductParams): Promise<Product> {
+    return this.client.post<Product>("/products", params);
+  }
+
+  async get(id: string): Promise<Product> {
+    return this.client.get<Product>(`/products/${id}`);
+  }
+
+  async update(id: string, params: UpdateProductParams): Promise<Product> {
+    return this.client.patch<Product>(`/products/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/products/${id}`);
+  }
+
+  async generateLink(id: string, params?: GenerateLinkParams): Promise<PaymentLink> {
+    return this.client.post<PaymentLink>(`/products/${id}/generate-link`, params ?? {});
+  }
+}

package/src/anyspend/platform/resources/transactions.ts

@@ -0,0 +1,33 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type {
+  Transaction,
+  TransactionStats,
+  ListResponse,
+  ListTransactionsParams,
+  ExportTransactionsParams,
+} from "../types";
+
+export class TransactionsResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListTransactionsParams): Promise<ListResponse<Transaction>> {
+    return this.client.get<ListResponse<Transaction>>("/transactions", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListTransactionsParams, "page">): AsyncGenerator<Transaction> {
+    yield* autoPaginate<Transaction>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async get(id: string): Promise<Transaction> {
+    return this.client.get<Transaction>(`/transactions/${id}`);
+  }
+
+  async stats(): Promise<TransactionStats> {
+    return this.client.get<TransactionStats>("/transactions/stats");
+  }
+
+  async export(params?: ExportTransactionsParams): Promise<string> {
+    return this.client.get<string>("/transactions/export", params);
+  }
+}

package/src/anyspend/platform/resources/webhooks.ts

@@ -0,0 +1,47 @@
+import type { HttpClient } from "../client";
+import type {
+  Webhook,
+  WebhookDelivery,
+  ListResponse,
+  DeletedResponse,
+  ActionResponse,
+  CreateWebhookParams,
+  UpdateWebhookParams,
+  PaginationParams,
+} from "../types";
+
+export class WebhooksResource {
+  constructor(private client: HttpClient) {}
+
+  async list(): Promise<ListResponse<Webhook>> {
+    return this.client.get<ListResponse<Webhook>>("/webhooks");
+  }
+
+  async create(params: CreateWebhookParams): Promise<Webhook> {
+    return this.client.post<Webhook>("/webhooks", params);
+  }
+
+  async get(id: string): Promise<Webhook> {
+    return this.client.get<Webhook>(`/webhooks/${id}`);
+  }
+
+  async update(id: string, params: UpdateWebhookParams): Promise<Webhook> {
+    return this.client.patch<Webhook>(`/webhooks/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/webhooks/${id}`);
+  }
+
+  async test(id: string): Promise<ActionResponse> {
+    return this.client.post<ActionResponse>(`/webhooks/${id}/test`);
+  }
+
+  async deliveries(id: string, params?: PaginationParams): Promise<ListResponse<WebhookDelivery>> {
+    return this.client.get<ListResponse<WebhookDelivery>>(`/webhooks/${id}/deliveries`, params);
+  }
+
+  async retry(id: string, deliveryId: string): Promise<ActionResponse> {
+    return this.client.post<ActionResponse>(`/webhooks/${id}/deliveries/${deliveryId}/retry`);
+  }
+}

package/src/anyspend/platform/resources/widgets.ts

@@ -0,0 +1,63 @@
+import type { HttpClient } from "../client";
+import { autoPaginate } from "../utils/pagination";
+import type { WidgetConfig, ListResponse, DeletedResponse, CreateWidgetParams, PaginationParams } from "../types";
+
+export interface ListWidgetsParams extends PaginationParams {
+  search?: string;
+  widget_type?: "swap" | "checkout" | "nft" | "deposit";
+  active?: "true" | "false";
+  sort?: "created_at" | "updated_at" | "name" | "current_views";
+  order?: "asc" | "desc";
+}
+
+export interface UpdateWidgetParams extends Partial<CreateWidgetParams> {
+  is_active?: boolean;
+}
+
+export interface WidgetStats {
+  object: "widget_stats";
+  widget_id: string;
+  summary: {
+    total_views: number;
+    total_interactions: number;
+    total_completions: number;
+  };
+  daily: {
+    date: string;
+    views: number;
+    interactions: number;
+    completions: number;
+  }[];
+}
+
+export class WidgetsResource {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListWidgetsParams): Promise<ListResponse<WidgetConfig>> {
+    return this.client.get<ListResponse<WidgetConfig>>("/widgets", params);
+  }
+
+  async *listAutoPaginate(params?: Omit<ListWidgetsParams, "page">): AsyncGenerator<WidgetConfig> {
+    yield* autoPaginate<WidgetConfig>((page, limit) => this.list({ ...params, page, limit }), { limit: params?.limit });
+  }
+
+  async create(params: CreateWidgetParams): Promise<WidgetConfig> {
+    return this.client.post<WidgetConfig>("/widgets", params);
+  }
+
+  async get(id: string): Promise<WidgetConfig> {
+    return this.client.get<WidgetConfig>(`/widgets/${id}`);
+  }
+
+  async update(id: string, params: UpdateWidgetParams): Promise<WidgetConfig> {
+    return this.client.patch<WidgetConfig>(`/widgets/${id}`, params);
+  }
+
+  async delete(id: string): Promise<DeletedResponse> {
+    return this.client.delete<DeletedResponse>(`/widgets/${id}`);
+  }
+
+  async stats(id: string, days?: number): Promise<WidgetStats> {
+    return this.client.get<WidgetStats>(`/widgets/${id}/stats`, days !== undefined ? { days } : undefined);
+  }
+}