@pindownai/client-js 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,544 @@
+/**
+ * API Types for Pindown
+ */
+interface ApiResponse<T = any> {
+    success: boolean;
+    data: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+type PinDataType = 'markdown' | 'json' | 'text' | 'pin-card';
+type PinCardType = 'stat-cards' | 'line-chart' | 'flexible-table' | 'embed' | 'markdown' | 'image' | 'score-gauge' | 'indicator-table' | 'alert-action' | 'bottom-detector' | 'long-short-pie';
+interface Pin {
+    id: string;
+    user_id: string;
+    owner_id: string;
+    data_type: PinDataType;
+    pin_card_type?: PinCardType;
+    content: any;
+    metadata?: {
+        name?: string;
+        description?: string;
+        tags?: string[];
+        [key: string]: any;
+    };
+    is_public: boolean;
+    allow_edit: boolean;
+    require_sign_in: boolean;
+    allow_comments: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface CreatePinRequest {
+    data_type: PinDataType;
+    pin_card_type?: PinCardType;
+    content: any;
+    metadata?: Pin['metadata'];
+}
+interface UpdatePinRequest {
+    content?: any;
+    metadata?: Pin['metadata'];
+}
+interface SharePinRequest {
+    is_public?: boolean;
+    allow_edit?: boolean;
+    require_sign_in?: boolean;
+    allow_comments?: boolean;
+}
+interface ListPinsOptions {
+    limit?: number;
+    offset?: number;
+}
+interface Pinboard {
+    id: string;
+    user_id: string;
+    title: string;
+    description?: string;
+    tags?: string[];
+    layout?: Record<string, any>;
+    mobile_layout?: Record<string, any>;
+    pins?: Pin[];
+    is_public: boolean;
+    allow_comments: boolean;
+    require_sign_in: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface CreatePinboardRequest {
+    title: string;
+    description?: string;
+    tags?: string[];
+    layout?: Record<string, any>;
+    mobile_layout?: Record<string, any>;
+}
+interface UpdatePinboardRequest {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    is_public?: boolean;
+    allow_comments?: boolean;
+    require_sign_in?: boolean;
+}
+interface AddPinToPinboardRequest {
+    pin_id: string;
+    position?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+interface UpdatePinboardLayoutRequest {
+    layout?: Record<string, any>;
+    mobile_layout?: Record<string, any>;
+}
+type DatasetType = 'json' | 'markdown';
+interface Dataset {
+    id: string;
+    user_id: string;
+    name: string;
+    type: DatasetType;
+    data: any;
+    description?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateDatasetRequest {
+    name: string;
+    type: DatasetType;
+    data: any;
+    description?: string;
+}
+interface UpdateDatasetRequest {
+    name?: string;
+    type?: DatasetType;
+    data?: any;
+    description?: string;
+}
+type BlockType = 'markdown' | 'mermaid' | 'conditional' | 'image' | 'stat-cards' | 'line-chart' | 'flexible-table' | 'embed';
+interface Block {
+    id: string;
+    pin_id: string;
+    name: string;
+    type: BlockType;
+    template: string | Record<string, any>;
+    order: number;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateBlockRequest {
+    name: string;
+    type: BlockType;
+    template: string | Record<string, any>;
+    order?: number;
+}
+interface UpdateBlockRequest {
+    name?: string;
+    type?: BlockType;
+    template?: string | Record<string, any>;
+    order?: number;
+}
+type CollaboratorRole = 'viewer' | 'editor' | 'owner';
+interface Collaborator {
+    user_id: string;
+    email: string;
+    role: CollaboratorRole;
+    added_at: string;
+}
+interface InviteCollaboratorRequest {
+    email: string;
+    role: CollaboratorRole;
+}
+interface UpdateCollaboratorRoleRequest {
+    role: CollaboratorRole;
+}
+interface Permissions {
+    role: CollaboratorRole;
+    can_view: boolean;
+    can_edit: boolean;
+    can_delete: boolean;
+    can_share: boolean;
+    can_manage_collaborators: boolean;
+}
+interface RateLimitInfo {
+    tier: string;
+    minute: {
+        limit: number;
+        used: number;
+        remaining: number;
+        resetAt: Date;
+    };
+    hour: {
+        limit: number;
+        used: number;
+        remaining: number;
+        resetAt: Date;
+    };
+}
+
+/**
+ * Pins API Methods
+ */
+
+declare class PinsMethods {
+    private client;
+    constructor(client: PindownClient);
+    /**
+     * Create a new pin
+     */
+    create(request: CreatePinRequest): Promise<Pin>;
+    /**
+     * Get a pin by ID
+     */
+    get(pinId: string): Promise<Pin>;
+    /**
+     * List all pins
+     */
+    list(options?: ListPinsOptions): Promise<PaginatedResponse<Pin>>;
+    /**
+     * Update a pin
+     */
+    update(pinId: string, request: UpdatePinRequest): Promise<Pin>;
+    /**
+     * Delete a pin
+     */
+    delete(pinId: string): Promise<void>;
+    /**
+     * Update pin sharing settings
+     */
+    share(pinId: string, request: SharePinRequest): Promise<Pin>;
+    /**
+     * Create a markdown pin
+     */
+    createMarkdown(content: string, metadata?: CreatePinRequest['metadata']): Promise<Pin>;
+    /**
+     * Create a stat card pin
+     */
+    createStatCard(data: {
+        title: string;
+        value: string | number;
+        change?: string;
+        icon?: string;
+    }, metadata?: CreatePinRequest['metadata']): Promise<Pin>;
+    /**
+     * Create a flexible table pin
+     */
+    createTable(data: {
+        columns: Array<{
+            id: string;
+            label: string;
+            type?: string;
+        }>;
+        rows: Array<Record<string, any>>;
+    }, metadata?: CreatePinRequest['metadata']): Promise<Pin>;
+    /**
+     * Create an embed pin (YouTube, Figma, etc.)
+     */
+    createEmbed(url: string, metadata?: CreatePinRequest['metadata']): Promise<Pin>;
+}
+
+/**
+ * Pinboards API Methods
+ */
+
+declare class PinboardsMethods {
+    private client;
+    constructor(client: PindownClient);
+    /**
+     * Create a new pinboard
+     */
+    create(request: CreatePinboardRequest): Promise<Pinboard>;
+    /**
+     * Get a pinboard by ID
+     */
+    get(boardId: string): Promise<Pinboard>;
+    /**
+     * List all pinboards
+     */
+    list(): Promise<Pinboard[]>;
+    /**
+     * Update a pinboard
+     */
+    update(boardId: string, request: UpdatePinboardRequest): Promise<Pinboard>;
+    /**
+     * Delete a pinboard
+     */
+    delete(boardId: string): Promise<void>;
+    /**
+     * Add a pin to a pinboard
+     */
+    addPin(boardId: string, request: AddPinToPinboardRequest): Promise<Pinboard>;
+    /**
+     * Remove a pin from a pinboard
+     */
+    removePin(boardId: string, pinId: string): Promise<void>;
+    /**
+     * Update pinboard layout
+     */
+    updateLayout(boardId: string, request: UpdatePinboardLayoutRequest): Promise<Pinboard>;
+    /**
+     * Update pinboard sharing settings
+     */
+    share(boardId: string, request: {
+        is_public?: boolean;
+        require_sign_in?: boolean;
+        allow_comments?: boolean;
+    }): Promise<Pinboard>;
+}
+
+/**
+ * Datasets API Methods
+ */
+
+declare class DatasetsMethods {
+    private client;
+    constructor(client: PindownClient);
+    /**
+     * Create a new dataset
+     */
+    create(request: CreateDatasetRequest): Promise<Dataset>;
+    /**
+     * Get a dataset by ID
+     */
+    get(datasetId: string): Promise<Dataset>;
+    /**
+     * List all datasets
+     */
+    list(): Promise<Dataset[]>;
+    /**
+     * Update a dataset
+     */
+    update(datasetId: string, request: UpdateDatasetRequest): Promise<Dataset>;
+    /**
+     * Delete a dataset
+     */
+    delete(datasetId: string): Promise<void>;
+}
+
+/**
+ * Blocks API Methods
+ */
+
+declare class BlocksMethods {
+    private client;
+    constructor(client: PindownClient);
+    /**
+     * Create a new block for a pin
+     */
+    create(pinId: string, request: CreateBlockRequest): Promise<Block>;
+    /**
+     * Get a block by ID
+     */
+    get(pinId: string, blockId: string): Promise<Block>;
+    /**
+     * List all blocks in a pin
+     */
+    list(pinId: string): Promise<Block[]>;
+    /**
+     * Update a block
+     */
+    update(pinId: string, blockId: string, request: UpdateBlockRequest): Promise<Block>;
+    /**
+     * Delete a block
+     */
+    delete(pinId: string, blockId: string): Promise<void>;
+}
+
+/**
+ * Collaborators API Methods
+ */
+
+declare class CollaboratorsMethods {
+    private client;
+    constructor(client: PindownClient);
+    /**
+     * List collaborators for a pin
+     */
+    listForPin(pinId: string): Promise<{
+        owner: Collaborator;
+        collaborators: Collaborator[];
+        pending_invites: Array<{
+            email: string;
+            role: string;
+            invited_at: string;
+        }>;
+    }>;
+    /**
+     * Invite a collaborator to a pin
+     */
+    inviteToPin(pinId: string, request: InviteCollaboratorRequest): Promise<void>;
+    /**
+     * Update a pin collaborator's role
+     */
+    updatePinRole(pinId: string, userId: string, request: UpdateCollaboratorRoleRequest): Promise<void>;
+    /**
+     * Remove a collaborator from a pin
+     */
+    removeFromPin(pinId: string, userId: string): Promise<void>;
+    /**
+     * Get current user's permissions for a pin
+     */
+    getPinPermissions(pinId: string): Promise<Permissions>;
+    /**
+     * List collaborators for a pinboard
+     */
+    listForPinboard(boardId: string): Promise<{
+        owner: Collaborator;
+        collaborators: Collaborator[];
+        pending_invites: Array<{
+            email: string;
+            role: string;
+            invited_at: string;
+        }>;
+    }>;
+    /**
+     * Invite a collaborator to a pinboard
+     */
+    inviteToPinboard(boardId: string, request: InviteCollaboratorRequest): Promise<void>;
+    /**
+     * Update a pinboard collaborator's role
+     */
+    updatePinboardRole(boardId: string, userId: string, request: UpdateCollaboratorRoleRequest): Promise<void>;
+    /**
+     * Remove a collaborator from a pinboard
+     */
+    removeFromPinboard(boardId: string, userId: string): Promise<void>;
+    /**
+     * Get current user's permissions for a pinboard
+     */
+    getPinboardPermissions(boardId: string): Promise<Permissions>;
+}
+
+/**
+ * Configuration types for Pindown API Client
+ */
+type Tier = 'starter' | 'hobby' | 'pro' | 'teams' | 'agency';
+interface PindownConfig {
+    /**
+     * Your Pindown API key (from https://pindown.ai/api-keys)
+     */
+    apiKey: string;
+    /**
+     * Your subscription tier (auto-detected from server if not provided)
+     * @internal Only use for testing - production should auto-detect
+     */
+    tier?: Tier;
+    /**
+     * Base URL for the API
+     * @default 'https://api.pindown.ai/api/v1'
+     */
+    baseURL?: string;
+    /**
+     * Enable rate limit tracking
+     * @default true
+     */
+    enableRateLimitTracking?: boolean;
+    /**
+     * Maximum number of retry attempts for failed requests
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Timeout for requests in milliseconds
+     * @default 30000 (30 seconds)
+     */
+    timeout?: number;
+}
+
+/**
+ * Pindown API Client
+ */
+
+declare class PindownClient {
+    private config;
+    private rateLimiter?;
+    private tierDetected;
+    readonly pins: PinsMethods;
+    readonly pinboards: PinboardsMethods;
+    readonly datasets: DatasetsMethods;
+    readonly blocks: BlocksMethods;
+    readonly collaborators: CollaboratorsMethods;
+    constructor(config: PindownConfig);
+    /**
+     * Core request method
+     */
+    request<T = any>(method: string, endpoint: string, data?: any): Promise<T>;
+    /**
+     * Handle error responses from API
+     */
+    private handleErrorResponse;
+    /**
+     * Detect tier from response headers
+     */
+    private detectTierFromHeaders;
+    /**
+     * Get current rate limit info
+     */
+    getRateLimitInfo(): RateLimitInfo | null;
+    /**
+     * Get current tier
+     */
+    getTier(): Tier | null;
+    /**
+     * Destroy the client (cleanup resources)
+     */
+    destroy(): void;
+}
+
+/**
+ * Error classes for Pindown API Client
+ */
+
+declare class PindownError extends Error {
+    constructor(message: string);
+}
+declare class AuthenticationError extends PindownError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends PindownError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends PindownError {
+    constructor(resource: string);
+}
+declare class ValidationError extends PindownError {
+    details?: any;
+    constructor(message: string, details?: any);
+}
+declare class RateLimitError extends PindownError {
+    window: 'minute' | 'hour';
+    limit: number;
+    used: number;
+    remaining: number;
+    resetAt: Date;
+    tier: Tier;
+    constructor(params: {
+        window: 'minute' | 'hour';
+        limit: number;
+        used: number;
+        remaining: number;
+        resetAt: Date;
+        tier: Tier;
+    });
+}
+declare class ServerError extends PindownError {
+    statusCode: number;
+    constructor(message: string, statusCode?: number);
+}
+declare class NetworkError extends PindownError {
+    constructor(message?: string);
+}
+
+export { type AddPinToPinboardRequest, type ApiResponse, AuthenticationError, type Block, type BlockType, type Collaborator, type CollaboratorRole, type CreateBlockRequest, type CreateDatasetRequest, type CreatePinRequest, type CreatePinboardRequest, type Dataset, type DatasetType, ForbiddenError, type InviteCollaboratorRequest, type ListPinsOptions, NetworkError, NotFoundError, type PaginatedResponse, type Permissions, type Pin, type PinCardType, type PinDataType, type Pinboard, PindownClient, type PindownConfig, PindownError, RateLimitError, type RateLimitInfo, ServerError, type SharePinRequest, type Tier, type UpdateBlockRequest, type UpdateCollaboratorRoleRequest, type UpdateDatasetRequest, type UpdatePinRequest, type UpdatePinboardLayoutRequest, type UpdatePinboardRequest, ValidationError };

package/dist/index.js

@@ -0,0 +1,9 @@
+var C={starter:{tokensPerHour:16,tokensPerMinute:null},hobby:{tokensPerHour:6e3,tokensPerMinute:100},pro:{tokensPerHour:24e3,tokensPerMinute:400},teams:{tokensPerHour:6e4,tokensPerMinute:1e3},agency:{tokensPerHour:24e4,tokensPerMinute:4e3}};var E={GET:1,POST:1,PUT:1,DELETE:1,INVITE:3,SHARE:3,BATCH_1_10:3,BATCH_11_25:5,BATCH_26_50:10};var o=class extends Error{constructor(e){super(e),this.name="PindownError";}},d=class extends o{constructor(e="Authentication failed"){super(e),this.name="AuthenticationError";}},p=class extends o{constructor(e="Access forbidden"){super(e),this.name="ForbiddenError";}},m=class extends o{constructor(e){super(`${e} not found`),this.name="NotFoundError";}},c=class extends o{constructor(e,t){super(e),this.name="ValidationError",this.details=t;}},P=class extends o{constructor(e){super(`Rate limit exceeded: ${e.used}/${e.limit} tokens used in ${e.window} window. Resets at ${e.resetAt.toISOString()}`),this.name="RateLimitError",this.window=e.window,this.limit=e.limit,this.used=e.used,this.remaining=e.remaining,this.resetAt=e.resetAt,this.tier=e.tier;}},l=class extends o{constructor(e,t=500){super(e),this.name="ServerError",this.statusCode=t;}},h=class extends o{constructor(e="Network request failed"){super(e),this.name="NetworkError";}};var $=C,g=E,b=class{constructor(e){this.minuteTokens=new Map;this.hourTokens=new Map;this.tier=e,this.cleanupInterval=setInterval(()=>this.cleanup(),300*1e3);}checkLimit(e,t,r){let n=this.calculateTokenCost(e,t,r),a=this.getMinuteWindow(),u=this.getHourWindow(),i=$[this.tier];if(i.tokensPerMinute!==null){let k=this.minuteTokens.get(a)||0;if(k+n>i.tokensPerMinute)throw new P({window:"minute",limit:i.tokensPerMinute,used:k,remaining:Math.max(0,i.tokensPerMinute-k),resetAt:this.getMinuteResetTime(),tier:this.tier})}let y=this.hourTokens.get(u)||0;if(y+n>i.tokensPerHour)throw new P({window:"hour",limit:i.tokensPerHour,used:y,remaining:Math.max(0,i.tokensPerHour-y),resetAt:this.getHourResetTime(),tier:this.tier});this.incrementToken(a,n),this.incrementToken(u,n);}calculateTokenCost(e,t,r){if(t.includes("/batch")||t.includes("/sync")){if(r?.operations){let n=Array.isArray(r.operations)?r.operations.length:0;return n<=10?g.BATCH_1_10:n<=25?g.BATCH_11_25:(g.BATCH_26_50)}if(r?.pins){let n=Array.isArray(r.pins)?r.pins.length:0;return n<=16?5:(8)}}return t.includes("/collaborators")||t.includes("/invite")||t.includes("/share")?g.INVITE:g[e]||1}getMinuteWindow(){let e=new Date;return `minute_${e.getFullYear()}-${String(e.getMonth()+1).padStart(2,"0")}-${String(e.getDate()).padStart(2,"0")}-${String(e.getHours()).padStart(2,"0")}-${String(e.getMinutes()).padStart(2,"0")}`}getHourWindow(){let e=new Date;return `hour_${e.getFullYear()}-${String(e.getMonth()+1).padStart(2,"0")}-${String(e.getDate()).padStart(2,"0")}-${String(e.getHours()).padStart(2,"0")}`}incrementToken(e,t){if(e.startsWith("minute")){let r=this.minuteTokens.get(e)||0;this.minuteTokens.set(e,r+t);}else {let r=this.hourTokens.get(e)||0;this.hourTokens.set(e,r+t);}}getMinuteResetTime(){let e=new Date;return new Date(e.getFullYear(),e.getMonth(),e.getDate(),e.getHours(),e.getMinutes()+1,0,0)}getHourResetTime(){let e=new Date;return new Date(e.getFullYear(),e.getMonth(),e.getDate(),e.getHours()+1,0,0,0)}getRateLimitInfo(){let e=$[this.tier],t=this.getMinuteWindow(),r=this.getHourWindow(),n=this.minuteTokens.get(t)||0,a=this.hourTokens.get(r)||0;return {tier:this.tier,minute:{limit:e.tokensPerMinute||0,used:n,remaining:e.tokensPerMinute?Math.max(0,e.tokensPerMinute-n):1/0,resetAt:this.getMinuteResetTime()},hour:{limit:e.tokensPerHour,used:a,remaining:Math.max(0,e.tokensPerHour-a),resetAt:this.getHourResetTime()}}}cleanup(){let t=Date.now()-7200*1e3;for(let[r]of this.minuteTokens)this.parseWindowTimestamp(r)<t&&this.minuteTokens.delete(r);for(let[r]of this.hourTokens)this.parseWindowTimestamp(r)<t&&this.hourTokens.delete(r);}parseWindowTimestamp(e){let t=e.split("_")[1].split("-"),r=parseInt(t[0]),n=parseInt(t[1])-1,a=parseInt(t[2]),u=parseInt(t[3]),i=e.startsWith("minute")?parseInt(t[4]):0;return new Date(r,n,a,u,i).getTime()}destroy(){this.cleanupInterval&&clearInterval(this.cleanupInterval);}};var T=class{constructor(e){this.client=e;}async create(e){return this.client.request("POST","/pins",e)}async get(e){return this.client.request("GET",`/pins/${e}`)}async list(e){let t=new URLSearchParams;e?.limit&&t.append("limit",e.limit.toString()),e?.offset&&t.append("offset",e.offset.toString());let r=t.toString(),n=r?`/pins?${r}`:"/pins";return this.client.request("GET",n)}async update(e,t){return this.client.request("PUT",`/pins/${e}`,t)}async delete(e){return this.client.request("DELETE",`/pins/${e}`)}async share(e,t){return this.client.request("POST",`/pins/${e}/share`,t)}async createMarkdown(e,t){return this.create({data_type:"markdown",content:e,metadata:t})}async createStatCard(e,t){return this.create({data_type:"pin-card",pin_card_type:"stat-cards",content:[e],metadata:t})}async createTable(e,t){return this.create({data_type:"pin-card",pin_card_type:"flexible-table",content:e,metadata:t})}async createEmbed(e,t){return this.create({data_type:"pin-card",pin_card_type:"embed",content:{url:e},metadata:t})}};var w=class{constructor(e){this.client=e;}async create(e){return this.client.request("POST","/pinboards",e)}async get(e){return this.client.request("GET",`/pinboards/${e}`)}async list(){return this.client.request("GET","/pinboards")}async update(e,t){return this.client.request("PUT",`/pinboards/${e}`,t)}async delete(e){return this.client.request("DELETE",`/pinboards/${e}`)}async addPin(e,t){return this.client.request("POST",`/pinboards/${e}/pins`,t)}async removePin(e,t){return this.client.request("DELETE",`/pinboards/${e}/pins/${t}`)}async updateLayout(e,t){return this.client.request("PUT",`/pinboards/${e}/layout`,t)}async share(e,t){return this.client.request("POST",`/pinboards/${e}/share`,t)}};var f=class{constructor(e){this.client=e;}async create(e){return this.client.request("POST","/datasets",e)}async get(e){return this.client.request("GET",`/datasets/${e}`)}async list(){return this.client.request("GET","/datasets")}async update(e,t){return this.client.request("PUT",`/datasets/${e}`,t)}async delete(e){return this.client.request("DELETE",`/datasets/${e}`)}};var R=class{constructor(e){this.client=e;}async create(e,t){return this.client.request("POST",`/pins/${e}/blocks`,t)}async get(e,t){return this.client.request("GET",`/pins/${e}/blocks/${t}`)}async list(e){return this.client.request("GET",`/pins/${e}/blocks`)}async update(e,t,r){return this.client.request("PUT",`/pins/${e}/blocks/${t}`,r)}async delete(e,t){return this.client.request("DELETE",`/pins/${e}/blocks/${t}`)}};var q=class{constructor(e){this.client=e;}async listForPin(e){return this.client.request("GET",`/pins/${e}/collaborators`)}async inviteToPin(e,t){return this.client.request("POST",`/pins/${e}/collaborators`,t)}async updatePinRole(e,t,r){return this.client.request("PUT",`/pins/${e}/collaborators/${t}`,r)}async removeFromPin(e,t){return this.client.request("DELETE",`/pins/${e}/collaborators/${t}`)}async getPinPermissions(e){return this.client.request("GET",`/pins/${e}/permissions`)}async listForPinboard(e){return this.client.request("GET",`/pinboards/${e}/collaborators`)}async inviteToPinboard(e,t){return this.client.request("POST",`/pinboards/${e}/collaborators`,t)}async updatePinboardRole(e,t,r){return this.client.request("PUT",`/pinboards/${e}/collaborators/${t}`,r)}async removeFromPinboard(e,t){return this.client.request("DELETE",`/pinboards/${e}/collaborators/${t}`)}async getPinboardPermissions(e){return this.client.request("GET",`/pinboards/${e}/permissions`)}};var v=class{constructor(e){this.tierDetected=false;if(!e.apiKey)throw new Error("API key is required");this.config={apiKey:e.apiKey,tier:e.tier,baseURL:e.baseURL||"https://api.pindown.ai/api/v1",enableRateLimitTracking:e.enableRateLimitTracking??true,maxRetries:e.maxRetries??3,timeout:e.timeout??3e4},this.config.tier&&(this.rateLimiter=new b(this.config.tier),this.tierDetected=true),this.pins=new T(this),this.pinboards=new w(this),this.datasets=new f(this),this.blocks=new R(this),this.collaborators=new q(this);}async request(e,t,r){this.config.enableRateLimitTracking&&this.rateLimiter&&this.rateLimiter.checkLimit(e,t,r);let n=`${this.config.baseURL}${t}`,a={Authorization:`Bearer ${this.config.apiKey}`,"Content-Type":"application/json"},u={method:e,headers:a,signal:AbortSignal.timeout(this.config.timeout)};r&&(e==="POST"||e==="PUT")&&(u.body=JSON.stringify(r));try{let i=await fetch(n,u);return !this.tierDetected&&this.config.enableRateLimitTracking&&this.detectTierFromHeaders(i.headers),i.ok||await this.handleErrorResponse(i),(await i.json()).data}catch(i){throw i instanceof d||i instanceof p||i instanceof m||i instanceof c||i instanceof l?i:i.name==="AbortError"||i.name==="TimeoutError"?new h("Request timeout"):new h(i.message||"Network request failed")}}async handleErrorResponse(e){let t;try{t=await e.json();}catch{t={message:e.statusText};}let r=t.error?.message||t.message||"Unknown error";switch(e.status){case 401:throw new d(r);case 403:throw new p(r);case 404:throw new m(r);case 400:case 422:throw new c(r,t.error?.details);case 429:throw new c("Rate limit exceeded (server)",t);case 500:case 502:case 503:throw new l(r,e.status);default:throw new l(r,e.status)}}detectTierFromHeaders(e){let t=e.get("X-RateLimit-Tier");if(t&&!this.rateLimiter){let r=t.toLowerCase();console.log(`[Pindown Client] Auto-detected tier: ${r}`),this.config.tier=r,this.rateLimiter=new b(r),this.tierDetected=true;}}getRateLimitInfo(){return this.rateLimiter?this.rateLimiter.getRateLimitInfo():null}getTier(){return this.config.tier||null}destroy(){this.rateLimiter&&this.rateLimiter.destroy();}};/**
+ * @pindownai/client-js
+ * 
+ * Official TypeScript/JavaScript client for Pindown.ai API
+ * 
+ * @author Pindown.ai
+ * @license MIT
+ */export{d as AuthenticationError,p as ForbiddenError,h as NetworkError,m as NotFoundError,v as PindownClient,o as PindownError,P as RateLimitError,l as ServerError,c as ValidationError};//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map