chariow-store-manager 1.0.0

package/README.md

@@ -0,0 +1,205 @@
+# chariow-store-manager
+
+A strictly typed Node.js wrapper for the [Chariow](https://chariow.dev) API.
+
+## Installation
+
+```bash
+npm install chariow-store-manager
+```
+
+## Usage
+
+### Initialization
+
+You can initialize the client with your API key directly:
+
+```typescript
+import { ChariowClient } from 'chariow-store-manager';
+
+const client = new ChariowClient({
+  apiKey: 'sk_live_...',
+  webhookSecret: 'whsec_...' // Optional: for verifying pulses (webhooks)
+});
+```
+
+Or rely on the `CHARIOW_API_KEY` and `CHARIOW_WEBHOOK_SECRET` environment variables:
+
+```typescript
+// Ensure CHARIOW_API_KEY is set in your environment
+const client = new ChariowClient();
+```
+
+### Products
+
+```typescript
+// List products with pagination and filtering
+const { data: products, pagination } = await client.products.list({ 
+  per_page: 10,
+  category: 'technology' 
+});
+
+// Get a single product (by ID or slug)
+const product = await client.products.retrieve('prd_abc123');
+console.log(product.description);
+```
+
+### Customers
+
+```typescript
+// List customers
+const { data: customers } = await client.customers.list({ search: 'john' });
+
+// Get a single customer
+const customer = await client.customers.retrieve('cus_ghi789');
+```
+
+### Sales
+
+```typescript
+// List sales
+const { data: sales } = await client.sales.list({ status: 'completed' });
+
+// Get a single sale
+const sale = await client.sales.retrieve('sal_abc123');
+console.log(sale.payment.status);
+```
+
+### Checkouts
+
+Create a checkout session for your customers:
+
+```typescript
+const checkout = await client.checkouts.create({
+  product_id: 'prd_abc123',
+  email: 'customer@example.com',
+  first_name: 'John',
+  last_name: 'Doe',
+  phone: {
+    number: '1234567890',
+    country_code: 'US'
+  },
+  redirect_url: 'https://yoursite.com/thank-you',
+  // Optional
+  discount_code: 'SAVE20',
+  custom_metadata: {
+    order_ref: 'ORD-123'
+  }
+});
+
+if (checkout.step === 'awaiting_payment' && checkout.payment.checkout_url) {
+  console.log('Redirect user to:', checkout.payment.checkout_url);
+} else if (checkout.step === 'completed') {
+  console.log('Purchase completed (free product)');
+}
+```
+
+### Discounts
+
+Manage discount codes:
+
+```typescript
+// Create a 20% off discount
+const discount = await client.discounts.create({
+  code: 'SUMMER20',
+  type: 'percentage',
+  value: 20,
+  usage_limit: 100
+});
+
+// List all discounts
+const { data: discounts } = await client.discounts.list();
+```
+
+### Affiliates
+
+Manage your affiliate program:
+
+```typescript
+// Register a new affiliate
+const affiliate = await client.affiliates.create({
+  code: 'INFLUENCER1',
+  commission_rate: 15, // 15% commission
+  paypal_email: 'influencer@example.com'
+});
+```
+
+### Pulses (Webhooks)
+
+Handle incoming webhooks securely with built-in signature verification.
+
+#### Using with Express/Node.js
+
+```typescript
+import express from 'express';
+import { ChariowClient } from 'chariow-store-manager';
+
+const app = express();
+const client = new ChariowClient();
+
+// Use raw body parser to verify signatures correctly
+app.post('/webhooks/chariow', express.raw({ type: 'application/json' }), async (req, res) => {
+  const signature = req.headers['x-chariow-signature'] as string;
+
+  try {
+    const event = client.pulses.constructEvent(req.body, signature);
+
+    // Handle specific events
+    if (event.type === 'sale.completed') {
+      console.log('Sale completed:', event.data.id);
+    }
+    
+    // Or use the event handler system
+    await client.pulses.handleEvent(event);
+
+    res.json({ received: true });
+  } catch (err) {
+    console.error('Webhook Error:', err.message);
+    res.status(400).send(`Webhook Error: ${err.message}`);
+  }
+});
+
+// Register event handlers elsewhere in your app
+client.pulses.on('sale.completed', async (event) => {
+  const sale = event.data;
+  console.log(`Processing sale ${sale.id} for product ${sale.product_id}`);
+  // Grant access, send email, etc.
+});
+```
+
+### Pagination & Filtering
+
+All list methods support pagination and filtering:
+
+```typescript
+const { data, pagination } = await client.sales.list({
+  per_page: 20,
+  cursor: 'eyJ...', // From previous response
+  status: 'completed', // Filter by status
+  customer_id: 'cus_123' // Filter by customer
+});
+```
+
+## Error Handling
+
+The client throws structured errors when the API returns a failure response.
+
+```typescript
+try {
+  await client.products.retrieve('invalid_id');
+} catch (error: any) {
+  if (error.response) {
+    // API returned an error response (4xx, 5xx)
+    console.error('API Error:', error.message);
+    console.error('Status:', error.status);
+    console.error('Details:', error.response.errors);
+  } else {
+    // Network error or other issue
+    console.error('Error:', error.message);
+  }
+}
+```
+
+## TypeScript Support
+
+This package is written in TypeScript and includes full type definitions.

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import { ChariowConfig } from './types';
+import { Products } from './resources/products';
+import { Customers } from './resources/customers';
+import { Sales } from './resources/sales';
+import { Licenses } from './resources/licenses';
+import { Checkouts } from './resources/checkouts';
+import { Discounts } from './resources/discounts';
+import { Affiliates } from './resources/affiliates';
+import { Pulses } from './resources/pulses';
+export declare class ChariowClient {
+    private _axios;
+    config: ChariowConfig;
+    products: Products;
+    customers: Customers;
+    sales: Sales;
+    licenses: Licenses;
+    checkouts: Checkouts;
+    discounts: Discounts;
+    affiliates: Affiliates;
+    pulses: Pulses;
+    constructor(config?: ChariowConfig);
+    get<T>(path: string, params?: any): Promise<T>;
+    post<T>(path: string, data?: any): Promise<T>;
+    put<T>(path: string, data?: any): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChariowClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const products_1 = require("./resources/products");
+const customers_1 = require("./resources/customers");
+const sales_1 = require("./resources/sales");
+const licenses_1 = require("./resources/licenses");
+const checkouts_1 = require("./resources/checkouts");
+const discounts_1 = require("./resources/discounts");
+const affiliates_1 = require("./resources/affiliates");
+const pulses_1 = require("./resources/pulses");
+const DEFAULT_BASE_URL = 'https://api.chariow.com/v1';
+class ChariowClient {
+    constructor(config = { apiKey: '' }) {
+        this.config = config;
+        const apiKey = config.apiKey || process.env.CHARIOW_API_KEY;
+        if (!apiKey) {
+            throw new Error('API key is required. Please provide it in the constructor or set CHARIOW_API_KEY environment variable.');
+        }
+        this._axios = axios_1.default.create({
+            baseURL: config.baseURL || DEFAULT_BASE_URL,
+            timeout: config.timeout || 10000,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'User-Agent': 'chariow-store-manager/1.0.0'
+            }
+        });
+        this._axios.interceptors.response.use((response) => response, (error) => {
+            if (error.response) {
+                const { status, data } = error.response;
+                // Handle rate limiting
+                if (status === 429) {
+                    console.warn('Chariow API Rate Limit Exceeded');
+                }
+                // Wrap error for better DX
+                const errorData = data;
+                const message = errorData.message || error.message;
+                const apiError = new Error(`Chariow API Error (${status}): ${message}`);
+                apiError.response = errorData;
+                apiError.status = status;
+                return Promise.reject(apiError);
+            }
+            return Promise.reject(error);
+        });
+        this.products = new products_1.Products(this);
+        this.customers = new customers_1.Customers(this);
+        this.sales = new sales_1.Sales(this);
+        this.licenses = new licenses_1.Licenses(this);
+        this.checkouts = new checkouts_1.Checkouts(this);
+        this.discounts = new discounts_1.Discounts(this);
+        this.affiliates = new affiliates_1.Affiliates(this);
+        this.pulses = new pulses_1.Pulses(this);
+    }
+    async get(path, params) {
+        const response = await this._axios.get(path, { params });
+        return response.data.data;
+    }
+    async post(path, data) {
+        const response = await this._axios.post(path, data);
+        return response.data.data;
+    }
+    async put(path, data) {
+        const response = await this._axios.put(path, data);
+        return response.data.data;
+    }
+    async delete(path) {
+        const response = await this._axios.delete(path);
+        return response.data.data;
+    }
+}
+exports.ChariowClient = ChariowClient;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './client';
+export * from './types';
+export * from './resources/base';
+export * from './resources/products';
+export * from './resources/customers';
+export * from './resources/sales';
+export * from './resources/licenses';
+export * from './resources/checkouts';
+export * from './resources/discounts';
+export * from './resources/affiliates';
+export * from './resources/pulses';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./resources/base"), exports);
+__exportStar(require("./resources/products"), exports);
+__exportStar(require("./resources/customers"), exports);
+__exportStar(require("./resources/sales"), exports);
+__exportStar(require("./resources/licenses"), exports);
+__exportStar(require("./resources/checkouts"), exports);
+__exportStar(require("./resources/discounts"), exports);
+__exportStar(require("./resources/affiliates"), exports);
+__exportStar(require("./resources/pulses"), exports);

package/dist/resources/affiliates.d.ts

@@ -0,0 +1,5 @@
+import { BaseResource } from './base';
+import { Affiliate, CreateAffiliateParams } from '../types';
+export declare class Affiliates extends BaseResource<Affiliate, CreateAffiliateParams> {
+    protected path: string;
+}

package/dist/resources/affiliates.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affiliates = void 0;
+const base_1 = require("./base");
+class Affiliates extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/affiliates';
+    }
+}
+exports.Affiliates = Affiliates;

package/dist/resources/base.d.ts

@@ -0,0 +1,12 @@
+import type { ChariowClient } from '../client';
+import { ListParams, PaginatedResponse } from '../types';
+export declare abstract class BaseResource<T, C = Partial<T>, U = Partial<T>> {
+    protected abstract path: string;
+    protected client: ChariowClient;
+    constructor(client: ChariowClient);
+    list(params?: ListParams): Promise<PaginatedResponse<T>>;
+    retrieve(id: string): Promise<T>;
+    create(data: C): Promise<T>;
+    update(id: string, data: U): Promise<T>;
+    delete(id: string): Promise<void>;
+}

package/dist/resources/base.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResource = void 0;
+class BaseResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get(this.path, params);
+    }
+    async retrieve(id) {
+        return this.client.get(`${this.path}/${id}`);
+    }
+    async create(data) {
+        return this.client.post(this.path, data);
+    }
+    async update(id, data) {
+        return this.client.put(`${this.path}/${id}`, data);
+    }
+    async delete(id) {
+        return this.client.delete(`${this.path}/${id}`);
+    }
+}
+exports.BaseResource = BaseResource;

package/dist/resources/checkouts.d.ts

@@ -0,0 +1,6 @@
+import { BaseResource } from './base';
+import { CheckoutResponseData, CreateCheckoutParams } from '../types';
+export declare class Checkouts extends BaseResource<CheckoutResponseData, CreateCheckoutParams> {
+    protected path: string;
+    create(data: CreateCheckoutParams): Promise<CheckoutResponseData>;
+}

package/dist/resources/checkouts.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkouts = void 0;
+const base_1 = require("./base");
+class Checkouts extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/checkout';
+    }
+    async create(data) {
+        return this.client.post(this.path, data);
+    }
+}
+exports.Checkouts = Checkouts;

package/dist/resources/customers.d.ts

@@ -0,0 +1,5 @@
+import { BaseResource } from './base';
+import { Customer } from '../types';
+export declare class Customers extends BaseResource<Customer> {
+    protected path: string;
+}

package/dist/resources/customers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Customers = void 0;
+const base_1 = require("./base");
+class Customers extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/customers';
+    }
+}
+exports.Customers = Customers;

package/dist/resources/discounts.d.ts

@@ -0,0 +1,5 @@
+import { BaseResource } from './base';
+import { Discount, CreateDiscountParams } from '../types';
+export declare class Discounts extends BaseResource<Discount, CreateDiscountParams> {
+    protected path: string;
+}

package/dist/resources/discounts.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Discounts = void 0;
+const base_1 = require("./base");
+class Discounts extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/discounts';
+    }
+}
+exports.Discounts = Discounts;

package/dist/resources/licenses.d.ts

@@ -0,0 +1,6 @@
+import { BaseResource } from './base';
+import { License, ValidateLicenseResponse } from '../types';
+export declare class Licenses extends BaseResource<License> {
+    protected path: string;
+    validate(key: string, product_id?: string): Promise<ValidateLicenseResponse>;
+}

package/dist/resources/licenses.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Licenses = void 0;
+const base_1 = require("./base");
+class Licenses extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/licenses';
+    }
+    async validate(key, product_id) {
+        return this.client.post(`${this.path}/validate`, { key, product_id });
+    }
+}
+exports.Licenses = Licenses;

package/dist/resources/products.d.ts

@@ -0,0 +1,5 @@
+import { BaseResource } from './base';
+import { Product } from '../types';
+export declare class Products extends BaseResource<Product> {
+    protected path: string;
+}

package/dist/resources/products.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Products = void 0;
+const base_1 = require("./base");
+class Products extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/products';
+    }
+}
+exports.Products = Products;

package/dist/resources/pulses.d.ts

@@ -0,0 +1,36 @@
+import { ChariowClient } from '../client';
+import { PulseEvent, PulseHandler } from '../types';
+export declare class Pulses {
+    protected client: ChariowClient;
+    private handlers;
+    constructor(client: ChariowClient);
+    /**
+     * Registers a handler for a specific pulse event type.
+     * @param eventType The event type to listen for (e.g., 'sale.created', '*')
+     * @param handler The function to execute when the event is received
+     */
+    on(eventType: string, handler: PulseHandler): void;
+    /**
+     * Removes a handler for a specific pulse event type.
+     * @param eventType The event type
+     * @param handler The handler function to remove
+     */
+    off(eventType: string, handler: PulseHandler): void;
+    /**
+     * Constructs a PulseEvent from the raw request body and signature.
+     * Verifies the signature if a webhook secret is configured.
+     *
+     * @param payload The raw request body (string or buffer)
+     * @param signature The signature from the X-Chariow-Signature header
+     * @returns The parsed PulseEvent
+     * @throws Error if signature verification fails
+     */
+    constructEvent(payload: string | Buffer, signature: string): PulseEvent;
+    /**
+     * Manually triggers the handlers for a given event.
+     * Useful when using the constructEvent method in your own webhook endpoint.
+     * @param event The parsed PulseEvent
+     */
+    handleEvent(event: PulseEvent): Promise<void>;
+    private verifySignature;
+}

package/dist/resources/pulses.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pulses = void 0;
+const crypto = __importStar(require("crypto"));
+class Pulses {
+    constructor(client) {
+        this.handlers = new Map();
+        this.client = client;
+    }
+    /**
+     * Registers a handler for a specific pulse event type.
+     * @param eventType The event type to listen for (e.g., 'sale.created', '*')
+     * @param handler The function to execute when the event is received
+     */
+    on(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, []);
+        }
+        this.handlers.get(eventType)?.push(handler);
+    }
+    /**
+     * Removes a handler for a specific pulse event type.
+     * @param eventType The event type
+     * @param handler The handler function to remove
+     */
+    off(eventType, handler) {
+        const handlers = this.handlers.get(eventType);
+        if (handlers) {
+            const index = handlers.indexOf(handler);
+            if (index !== -1) {
+                handlers.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Constructs a PulseEvent from the raw request body and signature.
+     * Verifies the signature if a webhook secret is configured.
+     *
+     * @param payload The raw request body (string or buffer)
+     * @param signature The signature from the X-Chariow-Signature header
+     * @returns The parsed PulseEvent
+     * @throws Error if signature verification fails
+     */
+    constructEvent(payload, signature) {
+        const secret = this.client.config.webhookSecret || process.env.CHARIOW_WEBHOOK_SECRET;
+        if (secret) {
+            this.verifySignature(payload, signature, secret);
+        }
+        else {
+            console.warn('No webhook secret provided. Skipping signature verification.');
+        }
+        const event = JSON.parse(payload.toString());
+        return event;
+    }
+    /**
+     * Manually triggers the handlers for a given event.
+     * Useful when using the constructEvent method in your own webhook endpoint.
+     * @param event The parsed PulseEvent
+     */
+    async handleEvent(event) {
+        const specificHandlers = this.handlers.get(event.type) || [];
+        const globalHandlers = this.handlers.get('*') || [];
+        const allHandlers = [...specificHandlers, ...globalHandlers];
+        await Promise.all(allHandlers.map(handler => handler(event)));
+    }
+    verifySignature(payload, signature, secret) {
+        // Assuming HMAC-SHA256 signature format: t=TIMESTAMP,v1=SIGNATURE or just SIGNATURE
+        // Adapting to a standard HMAC-SHA256 check for now.
+        // If Chariow uses a specific format (like Stripe's t=...,v1=...), this logic needs to be exact.
+        // For now, assuming raw hex digest of HMAC-SHA256(payload, secret).
+        const hmac = crypto.createHmac('sha256', secret);
+        hmac.update(payload);
+        const expectedSignature = hmac.digest('hex');
+        // Simple comparison (in production, use constant-time comparison)
+        // Note: If the signature header includes timestamp, this needs parsing.
+        // This is a basic implementation.
+        // Using crypto.timingSafeEqual for security if lengths match
+        const expectedBuffer = Buffer.from(expectedSignature);
+        const signatureBuffer = Buffer.from(signature);
+        if (expectedBuffer.length !== signatureBuffer.length || !crypto.timingSafeEqual(expectedBuffer, signatureBuffer)) {
+            throw new Error('Invalid signature');
+        }
+    }
+}
+exports.Pulses = Pulses;

package/dist/resources/sales.d.ts

@@ -0,0 +1,5 @@
+import { BaseResource } from './base';
+import { Sale } from '../types';
+export declare class Sales extends BaseResource<Sale> {
+    protected path: string;
+}

package/dist/resources/sales.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sales = void 0;
+const base_1 = require("./base");
+class Sales extends base_1.BaseResource {
+    constructor() {
+        super(...arguments);
+        this.path = '/sales';
+    }
+}
+exports.Sales = Sales;

package/dist/types.d.ts

@@ -0,0 +1,289 @@
+export interface ChariowConfig {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    webhookSecret?: string;
+}
+export interface ApiResponse<T> {
+    message: string;
+    data: T;
+    errors: string[];
+}
+export interface ApiErrorResponse {
+    message: string;
+    data: any[];
+    errors: Record<string, string[]>;
+}
+export interface Pagination {
+    next_cursor: string | null;
+    prev_cursor: string | null;
+    has_more: boolean;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: Pagination;
+}
+export interface ListParams {
+    cursor?: string;
+    per_page?: number;
+    search?: string;
+    start_date?: string;
+    end_date?: string;
+    [key: string]: any;
+}
+export interface Price {
+    value: number;
+    formatted: string;
+    short: string;
+    currency: string;
+}
+export interface ImageSet {
+    thumbnail: string;
+    cover: string;
+}
+export interface Category {
+    value: string;
+    label: string;
+}
+export interface Country {
+    name: string;
+    code: string;
+    alpha_3_code: string;
+    dial_code: string;
+    currency: string;
+    flag: string;
+}
+export interface Product {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    type: 'downloadable' | 'course' | 'license' | 'service' | 'bundle' | 'coaching';
+    category: Category;
+    status: 'draft' | 'published' | 'archived';
+    is_free: boolean;
+    pictures: ImageSet;
+    pricing: {
+        type: string;
+        price: Price;
+        current_price?: Price;
+        effective: Price;
+        sale_price: Price | null;
+        minimum_price?: Price;
+        suggested_price?: Price;
+        price_off: number | null;
+    };
+    has_variant_pricing: boolean;
+    quantity: number | null;
+    settings: {
+        is_shipping_address_required: boolean;
+    };
+    rating: {
+        average: number;
+        count: number;
+    };
+    on_sale_until: string | null;
+    sales_count: {
+        raw: number;
+        formatted: string;
+    };
+    seo: any | null;
+    custom_cta_text: {
+        value: string | null;
+        label: string | null;
+    };
+    fields: any[] | null;
+    store: any | null;
+    bundle: any | null;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface Customer {
+    id: string;
+    name: string;
+    first_name: string;
+    last_name: string;
+    email: string;
+    avatar_url: string | null;
+    phone: {
+        number: string;
+        country: Country;
+    } | null;
+    store?: {
+        id: string;
+        name: string;
+        logo_url: string;
+        url: string;
+    };
+    created_at: string;
+    updated_at: string;
+}
+export interface Sale {
+    id: string;
+    status: 'completed' | 'pending' | 'failed' | 'refunded' | 'awaiting_payment' | 'abandoned' | 'settled';
+    channel: {
+        value: string;
+        label: string;
+        description: string;
+    };
+    original_amount: Price;
+    amount: Price;
+    discount_amount: Price | null;
+    settlement?: {
+        amount: Price;
+        due_at: string;
+        done_at: string | null;
+        service_fee: Price;
+    };
+    download?: {
+        total: number;
+        last_at: string | null;
+    };
+    invoice_download_url?: string;
+    payment: {
+        status: string;
+        transaction_id: string | null;
+        gateway: string | null;
+        method?: {
+            name: string;
+            icon_url: string;
+        };
+        amount: Price;
+        fee: Price | null;
+        fee_rate: string | null;
+        exchange_rate: Price | null;
+        failure_error: string | null;
+    };
+    shipping?: {
+        address: string;
+        city: string;
+        state: string;
+        country: Country;
+        zip: string;
+    };
+    context?: {
+        user_agent: string;
+        ip_address: string;
+        country: Country;
+        device_type: string;
+        locale: string;
+    };
+    custom_fields_values?: any | null;
+    campaign?: {
+        id: string;
+        name: string;
+    } | null;
+    rating?: {
+        id: string;
+        is_thumbs_up: boolean;
+        comment: string | null;
+        created_at: string;
+    } | null;
+    store: {
+        id: string;
+        name: string;
+        logo_url: string;
+        url: string;
+    };
+    product: Partial<Product>;
+    customer: Partial<Customer>;
+    discount: {
+        id: string;
+        name: string;
+        code: string;
+    } | null;
+    store_affiliate?: any | null;
+    affiliate_commission?: any | null;
+    is_reconciled: boolean;
+    last_reconciled_at: string | null;
+    failed_at: string | null;
+    awaiting_payment_at: string | null;
+    abandoned_at: string | null;
+    completed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface License {
+    id: string;
+    key: string;
+    product_id: string;
+    customer_id: string;
+    status: 'active' | 'expired' | 'revoked';
+    expires_at?: string;
+    created_at: string;
+}
+export interface ValidateLicenseResponse {
+    valid: boolean;
+    license?: License;
+}
+export interface CheckoutPhone {
+    number: string;
+    country_code: string;
+}
+export interface CreateCheckoutParams {
+    product_id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    phone: CheckoutPhone;
+    discount_code?: string;
+    campaign_id?: string;
+    custom_fields?: Record<string, any>;
+    payment_currency?: string;
+    redirect_url?: string;
+    custom_metadata?: Record<string, string>;
+    address?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    zip?: string;
+}
+export interface CheckoutResponseData {
+    step: 'awaiting_payment' | 'completed' | 'already_purchased';
+    message: string | null;
+    purchase: Partial<Sale> | null;
+    payment: {
+        checkout_url: string | null;
+        transaction_id: string | null;
+    };
+}
+export interface Discount {
+    id: string;
+    code: string;
+    type: 'percentage' | 'fixed_amount';
+    value: number;
+    currency?: string;
+    usage_limit?: number;
+    usage_count: number;
+    active: boolean;
+    created_at: string;
+}
+export interface CreateDiscountParams {
+    code: string;
+    type: 'percentage' | 'fixed_amount';
+    value: number;
+    currency?: string;
+    usage_limit?: number;
+    active?: boolean;
+}
+export interface Affiliate {
+    id: string;
+    code: string;
+    commission_rate: number;
+    paypal_email?: string;
+    status: 'active' | 'inactive';
+    created_at: string;
+}
+export interface CreateAffiliateParams {
+    code: string;
+    commission_rate: number;
+    paypal_email?: string;
+    status?: 'active' | 'inactive';
+}
+export interface PulseEvent<T = any> {
+    id: string;
+    type: string;
+    data: T;
+    created_at: string;
+}
+export type PulseHandler = (event: PulseEvent) => void | Promise<void>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "chariow-store-manager",
+  "version": "1.0.0",
+  "description": "A simply nodejs package to use the Chariow API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "chariow",
+    "api",
+    "sdk"
+  ],
+  "author": "amos-gabriel",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "axios": "^1.13.5",
+    "typescript": "^5.9.3"
+  }
+}