@canveletedotcom/sdk 2.0.0

package/dist/resources/billing.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Billing resource for managing subscriptions, credits, and invoices
+ */
+import type { CanveleteClient } from '../client';
+import type { PaginatedResponse } from '../types';
+export interface BillingInfo {
+    plan: string;
+    status: 'active' | 'cancelled' | 'past_due' | 'trialing';
+    creditBalance: number;
+    creditLimit: number;
+    nextBillingDate: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+}
+export interface Invoice {
+    id: string;
+    date: string;
+    amount: number;
+    currency: string;
+    status: 'paid' | 'pending' | 'failed';
+    description: string;
+    pdfUrl?: string;
+}
+export interface BillingSummary {
+    totalSpent: number;
+    currentMonth: number;
+    previousMonth: number;
+    averageMonthly: number;
+    currency: string;
+}
+export interface Seats {
+    used: number;
+    total: number;
+    available: number;
+}
+export interface CreditPurchase {
+    id: string;
+    amount: number;
+    credits: number;
+    newBalance: number;
+    status: string;
+}
+export declare class BillingResource {
+    private client;
+    constructor(client: CanveleteClient);
+    /**
+     * Get billing information and subscription details
+     */
+    getInfo(): Promise<{
+        data: BillingInfo;
+    }>;
+    /**
+     * Get invoice history
+     */
+    getInvoices(options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<Invoice>>;
+    /**
+     * Get billing summary
+     */
+    getSummary(): Promise<{
+        data: BillingSummary;
+    }>;
+    /**
+     * Purchase additional credits
+     */
+    purchaseCredits(amount: number, paymentMethodId?: string): Promise<{
+        data: CreditPurchase;
+    }>;
+    /**
+     * Get team seats information
+     */
+    getSeats(): Promise<{
+        data: Seats;
+    }>;
+    /**
+     * Add team seats
+     */
+    addSeats(count: number): Promise<{
+        data: Seats;
+    }>;
+    /**
+     * Remove team seats
+     */
+    removeSeats(count: number): Promise<{
+        data: Seats;
+    }>;
+    /**
+     * Get billing portal URL
+     */
+    getPortalUrl(): Promise<{
+        url: string;
+    }>;
+}

package/dist/resources/billing.js

@@ -0,0 +1,64 @@
+/**
+ * Billing resource for managing subscriptions, credits, and invoices
+ */
+export class BillingResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get billing information and subscription details
+     */
+    async getInfo() {
+        return await this.client.request('GET', '/api/v1/billing/info');
+    }
+    /**
+     * Get invoice history
+     */
+    async getInvoices(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        return await this.client.request('GET', '/api/v1/billing/invoices', { params });
+    }
+    /**
+     * Get billing summary
+     */
+    async getSummary() {
+        return await this.client.request('GET', '/api/v1/billing/summary');
+    }
+    /**
+     * Purchase additional credits
+     */
+    async purchaseCredits(amount, paymentMethodId) {
+        const payload = { creditAmount: amount };
+        if (paymentMethodId) {
+            payload.paymentMethodId = paymentMethodId;
+        }
+        return await this.client.request('POST', '/api/v1/billing/credits/purchase', { json: payload });
+    }
+    /**
+     * Get team seats information
+     */
+    async getSeats() {
+        return await this.client.request('GET', '/api/v1/billing/seats');
+    }
+    /**
+     * Add team seats
+     */
+    async addSeats(count) {
+        return await this.client.request('POST', '/api/v1/billing/seats/add', { json: { count } });
+    }
+    /**
+     * Remove team seats
+     */
+    async removeSeats(count) {
+        return await this.client.request('DELETE', '/api/v1/billing/seats/remove', { json: { count } });
+    }
+    /**
+     * Get billing portal URL
+     */
+    async getPortalUrl() {
+        return await this.client.request('GET', '/api/billing/portal');
+    }
+}

package/dist/resources/canvas.d.ts

@@ -0,0 +1,36 @@
+import type { CanveleteClient } from '../client';
+export interface CanvasElement {
+    type: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    [key: string]: any;
+}
+export declare class CanvasResource {
+    private client;
+    constructor(client: CanveleteClient);
+    addElement(designId: string, element: CanvasElement): Promise<{
+        data: CanvasElement;
+    }>;
+    updateElement(designId: string, elementId: string, updates: Partial<CanvasElement>): Promise<{
+        data: CanvasElement;
+    }>;
+    deleteElement(designId: string, elementId: string): Promise<{
+        success: boolean;
+    }>;
+    getElements(designId: string): Promise<{
+        data: {
+            elements: CanvasElement[];
+        };
+    }>;
+    resize(designId: string, width: number, height: number): Promise<{
+        data: any;
+    }>;
+    clear(designId: string): Promise<{
+        success: boolean;
+    }>;
+    updateBackground(designId: string, background: string): Promise<{
+        data: any;
+    }>;
+}

package/dist/resources/canvas.js

@@ -0,0 +1,26 @@
+export class CanvasResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async addElement(designId, element) {
+        return await this.client.request('POST', `/api/designs/${designId}/elements`, { json: { element } });
+    }
+    async updateElement(designId, elementId, updates) {
+        return await this.client.request('PATCH', `/api/designs/${designId}/elements/${elementId}`, { json: updates });
+    }
+    async deleteElement(designId, elementId) {
+        return await this.client.request('DELETE', `/api/designs/${designId}/elements/${elementId}`);
+    }
+    async getElements(designId) {
+        return await this.client.request('GET', `/api/designs/${designId}/canvas`);
+    }
+    async resize(designId, width, height) {
+        return await this.client.request('PATCH', `/api/designs/${designId}/canvas/resize`, { json: { width, height } });
+    }
+    async clear(designId) {
+        return await this.client.request('DELETE', `/api/designs/${designId}/canvas/elements`);
+    }
+    async updateBackground(designId, background) {
+        return await this.client.request('PATCH', `/api/designs/${designId}/canvas/background`, { json: { background } });
+    }
+}

package/dist/resources/designs.d.ts

@@ -0,0 +1,42 @@
+import type { CanveleteClient } from '../client';
+import type { Design, PaginatedResponse } from '../types';
+export interface ListDesignsOptions {
+    page?: number;
+    limit?: number;
+    isTemplate?: boolean;
+    status?: 'DRAFT' | 'PUBLISHED' | 'ARCHIVED';
+}
+export interface CreateDesignData {
+    name: string;
+    description?: string;
+    canvasData: Record<string, any>;
+    width?: number;
+    height?: number;
+    isTemplate?: boolean;
+    visibility?: 'PRIVATE' | 'PUBLIC' | 'TEAM';
+}
+export interface UpdateDesignData {
+    name?: string;
+    description?: string;
+    canvasData?: Record<string, any>;
+    width?: number;
+    height?: number;
+    status?: 'DRAFT' | 'PUBLISHED' | 'ARCHIVED';
+    visibility?: 'PRIVATE' | 'PUBLIC' | 'TEAM';
+}
+export declare class DesignsResource {
+    private client;
+    constructor(client: CanveleteClient);
+    list(options?: ListDesignsOptions): Promise<PaginatedResponse<Design>>;
+    iterateAll(options?: ListDesignsOptions): AsyncGenerator<Design>;
+    create(data: CreateDesignData): Promise<{
+        data: Design;
+    }>;
+    get(id: string): Promise<{
+        data: Design;
+    }>;
+    update(id: string, data: UpdateDesignData): Promise<{
+        data: Design;
+    }>;
+    delete(id: string): Promise<void>;
+}

package/dist/resources/designs.js

@@ -0,0 +1,46 @@
+export class DesignsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        if (options.isTemplate !== undefined) {
+            params.isTemplate = options.isTemplate ? 'true' : 'false';
+        }
+        if (options.status) {
+            params.status = options.status;
+        }
+        return await this.client.request('GET', '/api/automation/designs', { params });
+    }
+    async *iterateAll(options = {}) {
+        let page = 1;
+        const limit = options.limit || 50;
+        while (true) {
+            const response = await this.list({ ...options, page, limit });
+            const designs = response.data || [];
+            if (designs.length === 0)
+                break;
+            for (const design of designs) {
+                yield design;
+            }
+            if (page >= (response.pagination?.totalPages || 1))
+                break;
+            page++;
+        }
+    }
+    async create(data) {
+        return await this.client.request('POST', '/api/automation/designs', { json: data });
+    }
+    async get(id) {
+        return await this.client.request('GET', `/api/automation/designs/${id}`);
+    }
+    async update(id, data) {
+        return await this.client.request('PATCH', `/api/automation/designs/${id}`, { json: data });
+    }
+    async delete(id) {
+        await this.client.request('DELETE', `/api/automation/designs/${id}`);
+    }
+}

package/dist/resources/index.d.ts

@@ -0,0 +1,15 @@
+export { DesignsResource } from './designs';
+export type { ListDesignsOptions, CreateDesignData, UpdateDesignData } from './designs';
+export { TemplatesResource } from './templates';
+export type { ListTemplatesOptions, ApplyTemplateOptions, CreateTemplateOptions } from './templates';
+export { RenderResource } from './render';
+export type { RenderOptions, RenderRecord, ListRenderOptions, AsyncRenderResponse, BatchRenderOptions, BatchRenderResponse } from './render';
+export { APIKeysResource } from './apiKeys';
+export type { ListAPIKeysOptions, CreateAPIKeyData, CreateAPIKeyResponse } from './apiKeys';
+export { CanvasResource } from './canvas';
+export { AssetsResource } from './assets';
+export type { Asset, StockImage, Icon, Font, ListAssetsOptions, SearchOptions } from './assets';
+export { UsageResource } from './usage';
+export type { UsageStats, UsageEvent, ApiStats, Activity, Analytics, UsageHistoryOptions } from './usage';
+export { BillingResource } from './billing';
+export type { BillingInfo, Invoice, BillingSummary, Seats, CreditPurchase } from './billing';

package/dist/resources/index.js

@@ -0,0 +1,9 @@
+export { DesignsResource } from './designs';
+export { TemplatesResource } from './templates';
+export { RenderResource } from './render';
+export { APIKeysResource } from './apiKeys';
+export { CanvasResource } from './canvas';
+// CanvasElement type is exported from types/index.ts
+export { AssetsResource } from './assets';
+export { UsageResource } from './usage';
+export { BillingResource } from './billing';

package/dist/resources/render.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Render resource for creating and managing render jobs
+ */
+import type { CanveleteClient } from '../client';
+import type { PaginatedResponse } from '../types';
+export interface RenderOptions {
+    designId?: string;
+    templateId?: string;
+    dynamicData?: Record<string, any>;
+    format?: 'png' | 'jpg' | 'jpeg' | 'pdf' | 'svg';
+    width?: number;
+    height?: number;
+    quality?: number;
+    outputFile?: string;
+}
+export interface RenderRecord {
+    id: string;
+    designId: string;
+    format: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    outputUrl?: string;
+    fileSize: number;
+    createdAt: string;
+    completedAt?: string;
+    error?: string;
+}
+export interface AsyncRenderResponse {
+    jobId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    estimatedTime?: number;
+}
+export interface BatchRenderOptions {
+    renders: RenderOptions[];
+    webhook?: string;
+}
+export interface BatchRenderResponse {
+    batchId: string;
+    jobs: AsyncRenderResponse[];
+    totalJobs: number;
+}
+export interface ListRenderOptions {
+    page?: number;
+    limit?: number;
+}
+export declare class RenderResource {
+    private client;
+    constructor(client: CanveleteClient);
+    /**
+     * Create a synchronous render (waits for completion)
+     */
+    create(options: RenderOptions): Promise<ArrayBuffer>;
+    /**
+     * Create an asynchronous render job (returns immediately)
+     */
+    createAsync(options: RenderOptions): Promise<AsyncRenderResponse>;
+    /**
+     * Get the status of a render job
+     */
+    getStatus(jobId: string): Promise<RenderRecord>;
+    /**
+     * Wait for a render job to complete
+     */
+    waitForCompletion(jobId: string, options?: {
+        timeout?: number;
+        pollInterval?: number;
+    }): Promise<RenderRecord>;
+    /**
+     * Get render history
+     */
+    getHistory(options?: ListRenderOptions): Promise<PaginatedResponse<RenderRecord>>;
+    /**
+     * Create a batch of render jobs
+     */
+    batchCreate(options: BatchRenderOptions): Promise<BatchRenderResponse>;
+    /**
+     * Wait for all jobs in a batch to complete
+     */
+    waitForBatch(batchId: string, options?: {
+        timeout?: number;
+        pollInterval?: number;
+    }): Promise<RenderRecord[]>;
+    /**
+     * List render history (legacy method)
+     */
+    list(options?: ListRenderOptions): Promise<PaginatedResponse<RenderRecord>>;
+    /**
+     * Iterate through all render records with automatic pagination
+     */
+    iterateAll(options?: ListRenderOptions): AsyncGenerator<RenderRecord>;
+}

package/dist/resources/render.js

@@ -0,0 +1,171 @@
+/**
+ * Render resource for creating and managing render jobs
+ */
+import { writeFileSync } from 'fs';
+import { ValidationError } from '../errors';
+export class RenderResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a synchronous render (waits for completion)
+     */
+    async create(options) {
+        if (!options.designId && !options.templateId) {
+            throw new ValidationError('Either designId or templateId is required');
+        }
+        const data = {
+            format: options.format || 'png',
+            quality: options.quality || 90,
+        };
+        if (options.designId)
+            data.designId = options.designId;
+        if (options.templateId)
+            data.templateId = options.templateId;
+        if (options.dynamicData)
+            data.dynamicData = options.dynamicData;
+        if (options.width)
+            data.width = options.width;
+        if (options.height)
+            data.height = options.height;
+        const imageData = await this.client.request('POST', '/api/automation/render', {
+            json: data,
+            binary: true,
+        });
+        if (options.outputFile) {
+            writeFileSync(options.outputFile, Buffer.from(imageData));
+        }
+        return imageData;
+    }
+    /**
+     * Create an asynchronous render job (returns immediately)
+     */
+    async createAsync(options) {
+        if (!options.designId && !options.templateId) {
+            throw new ValidationError('Either designId or templateId is required');
+        }
+        const data = {
+            format: options.format || 'png',
+            quality: options.quality || 90,
+            async: true,
+        };
+        if (options.designId)
+            data.designId = options.designId;
+        if (options.templateId)
+            data.templateId = options.templateId;
+        if (options.dynamicData)
+            data.dynamicData = options.dynamicData;
+        if (options.width)
+            data.width = options.width;
+        if (options.height)
+            data.height = options.height;
+        return await this.client.request('POST', '/api/v1/render/async', {
+            json: data,
+        });
+    }
+    /**
+     * Get the status of a render job
+     */
+    async getStatus(jobId) {
+        return await this.client.request('GET', `/api/v1/render/status/${jobId}`);
+    }
+    /**
+     * Wait for a render job to complete
+     */
+    async waitForCompletion(jobId, options = {}) {
+        const timeout = options.timeout || 300000; // 5 minutes default
+        const pollInterval = options.pollInterval || 2000; // 2 seconds default
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const status = await this.getStatus(jobId);
+            if (status.status === 'completed') {
+                return status;
+            }
+            if (status.status === 'failed') {
+                throw new Error(`Render job failed: ${status.error || 'Unknown error'}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`Render job timed out after ${timeout}ms`);
+    }
+    /**
+     * Get render history
+     */
+    async getHistory(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        return await this.client.request('GET', '/api/v1/render/history', { params });
+    }
+    /**
+     * Create a batch of render jobs
+     */
+    async batchCreate(options) {
+        if (!options.renders || options.renders.length === 0) {
+            throw new ValidationError('At least one render is required');
+        }
+        const payload = {
+            renders: options.renders.map(r => ({
+                designId: r.designId,
+                templateId: r.templateId,
+                dynamicData: r.dynamicData,
+                format: r.format || 'png',
+                quality: r.quality || 90,
+                width: r.width,
+                height: r.height,
+            })),
+        };
+        if (options.webhook) {
+            payload.webhook = options.webhook;
+        }
+        return await this.client.request('POST', '/api/v1/render/batch', {
+            json: payload,
+        });
+    }
+    /**
+     * Wait for all jobs in a batch to complete
+     */
+    async waitForBatch(batchId, options = {}) {
+        const timeout = options.timeout || 600000; // 10 minutes default
+        const pollInterval = options.pollInterval || 5000; // 5 seconds default
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const response = await this.client.request('GET', `/api/v1/render/batch/${batchId}/status`);
+            if (response.completed) {
+                return response.jobs;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`Batch render timed out after ${timeout}ms`);
+    }
+    /**
+     * List render history (legacy method)
+     */
+    async list(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        return await this.client.request('GET', '/api/automation/render', { params });
+    }
+    /**
+     * Iterate through all render records with automatic pagination
+     */
+    async *iterateAll(options = {}) {
+        let page = 1;
+        const limit = options.limit || 50;
+        while (true) {
+            const response = await this.list({ page, limit });
+            const renders = response.data || [];
+            if (renders.length === 0)
+                break;
+            for (const render of renders) {
+                yield render;
+            }
+            if (page >= (response.pagination?.totalPages || 1))
+                break;
+            page++;
+        }
+    }
+}

package/dist/resources/templates.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Templates resource for managing design templates
+ */
+import type { CanveleteClient } from '../client';
+import type { Template, PaginatedResponse, Design } from '../types';
+export interface ListTemplatesOptions {
+    page?: number;
+    limit?: number;
+    myOnly?: boolean;
+    search?: string;
+    category?: string;
+}
+export interface ApplyTemplateOptions {
+    designId: string;
+    templateId: string;
+    dynamicData?: Record<string, any>;
+}
+export interface CreateTemplateOptions {
+    designId: string;
+    name: string;
+    description?: string;
+    category?: string;
+}
+export declare class TemplatesResource {
+    private client;
+    constructor(client: CanveleteClient);
+    /**
+     * List available templates
+     */
+    list(options?: ListTemplatesOptions): Promise<PaginatedResponse<Template>>;
+    /**
+     * Iterate through all templates with automatic pagination
+     */
+    iterateAll(options?: ListTemplatesOptions): AsyncGenerator<Template>;
+    /**
+     * Get a specific template by ID
+     */
+    get(id: string): Promise<{
+        data: Template;
+    }>;
+    /**
+     * Apply a template to a design
+     */
+    apply(options: ApplyTemplateOptions): Promise<{
+        data: Design;
+    }>;
+    /**
+     * Create a template from an existing design
+     */
+    create(options: CreateTemplateOptions): Promise<{
+        data: Template;
+    }>;
+}