@ptkl/sdk 0.10.2 → 1.0.1

package/dist/v0.9/api/component.d.ts

@@ -0,0 +1,136 @@
+import { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, ModifyOptions, StreamHandler, AggregateChainable, ComponentOptions, UpdateManyOptions, CreateManyOptions } from "../types/component";
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+export default class Component extends PlatformBaseClient {
+    private ref;
+    private version;
+    constructor(ref?: string | null, options?: ComponentOptions);
+    /**
+     * Get the base path for component API calls
+     * @private
+     */
+    private getComponentPath;
+    /**
+     * Find method to search for models
+     *
+     * @param {FindParams} filters - The filters to apply to the search
+     * @param {FindOptions} opts - The options to apply to the search
+     *
+     * @returns {Promise<FindResponse>} - The result of the search
+     *
+     * @example
+     * platform.component(name).find({
+     *     currentPage: 1,
+     *     perPage: 10,
+     * })
+     *
+     * // advanced search
+     * platform.component(name).find({
+     *     $adv: {
+     *         name: "John Doe",
+     *     }
+     * )
+     **/
+    find(filters: FindParams, opts?: FindOptions): Promise<AxiosResponse<FindResponse>>;
+    /**
+     * FindOne method to search for a single model
+     *
+     * @param {FindAdvancedParams} filter - The filters to apply to the search
+     * @param {FindOptions} opts - The options to apply to the search
+     *
+     * @returns {Promise<?Model>} - The result of the search
+     *
+     * @example
+     * platform.component(name).findOne({
+     *     name: "John Doe",
+     * })
+     **/
+    findOne(filter: FindAdvancedParams, opts: FindOptions): Promise<Model | null>;
+    /**
+     * Get model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @returns (Promise<Model>)
+     */
+    get(uuid: string): Promise<AxiosResponse<Model>>;
+    /**
+     * Update model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @param data
+     * @returns
+     */
+    update(uuid: string, data: Record<string, any>, options: UpdateOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Update many models
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    updateMany(data: Record<string, any>[], options: UpdateManyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Create many models
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    createMany(data: Record<string, any>[], options: CreateManyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Modify models by filters
+     *
+     * @param data
+     * @param options
+     * @returns
+     */
+    modify(filters: Record<string, any>, data: Record<string, any>, options: ModifyOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Concurrent update model by uuid
+     *
+     * @param uuid string - The uuid of the model
+     * @param version number - The version of the model
+     * @param data
+     * @returns
+     */
+    concurrentUpdate(uuid: string, version: number, data: Record<string, any>, options: UpdateOptions): Promise<AxiosResponse<any, any>>;
+    create(model: Record<string, any>): Promise<AxiosResponse<any, any>>;
+    delete(uuid: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Execute aggregate pipeline with optional streaming support
+     *
+     * Returns a chainable object that allows both buffered and streaming modes.
+     * Call .onData() to enable streaming mode, or await directly for buffered mode.
+     *
+     * @param {FindAggregateParams} pipeline - MongoDB aggregation pipeline
+     *
+     * @returns {AggregateChainable} Chainable object with streaming methods and Promise interface
+     *
+     * @example
+     * ```typescript
+     * // Buffered response (default, up to 5K documents)
+     * const result = await component.aggregate([{ $match: { status: 'active' } }]);
+     * console.log(result.data); // All results at once
+     *
+     * // Streaming response (up to 25K documents)
+     * await component.aggregate([{ $match: { status: 'active' } }])
+     *   .onData((doc) => console.log('Received:', doc))
+     *   .onError((err) => console.error('Error:', err))
+     *   .onEnd(() => console.log('Stream complete'));
+     * ```
+     */
+    aggregate(pipeline: FindAggregateParams): AggregateChainable;
+    settings(): Promise<AxiosResponse<any, any>>;
+    saveSettings(settings: any, version: string): Promise<AxiosResponse<any, any>>;
+    saveTemplatesDist(version: string, sdkVersion: string, engine: string, dist: Record<string, string>): Promise<any>;
+    workflow(event: string, input: any): Promise<AxiosResponse<any, any>>;
+    function(name: string, input: any): Promise<AxiosResponse<any, any>>;
+    revisions(uuid: string): Promise<AxiosResponse<any, any>>;
+    /**
+     * Internal method to handle NDJSON streaming responses
+     *
+     * @private
+     */
+    private _streamNDJSON;
+}
+export { FindParams, FindOptions, FindResponse, FindAdvancedParams, FindAggregateParams, Model, UpdateOptions, StreamHandler, AggregateChainable, ComponentOptions, };

package/dist/v0.9/api/config.d.ts

@@ -0,0 +1,14 @@
+import PlatformBaseClient from "./platformBaseClient";
+import { AxiosResponse } from "axios";
+import { ConfigUpdateRequest, UserConfig } from '../types/config';
+export default class Config extends PlatformBaseClient {
+    /**
+     * Get user configuration
+     */
+    getUserConfig(): Promise<AxiosResponse<UserConfig>>;
+    /**
+     * Update user configuration
+     * @param config Configuration data
+     */
+    updateUserConfig(config: ConfigUpdateRequest): Promise<AxiosResponse<any>>;
+}

package/dist/v0.9/api/forge.d.ts

@@ -0,0 +1,7 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Forge extends PlatformBaseClient {
+    bundleUpload(buffer: Buffer): Promise<any>;
+    getWorkspaceApps(): Promise<any>;
+    removeVersion(ref: string, version: string): Promise<any>;
+    list(): Promise<any>;
+}

package/dist/v0.9/api/functions.d.ts

@@ -0,0 +1,23 @@
+import PlatformBaseClient from "./platformBaseClient";
+export default class Functions extends PlatformBaseClient {
+    list(): Promise<any>;
+    get(ref: string): Promise<any>;
+    update(uuid: string, update: any): Promise<any>;
+    /**
+     * Run platform function
+     *
+     * @param id - Function ID
+     * @param input - Input data
+     * @param query - Query parameters
+     * @returns - Function result
+     *
+     * @example
+     * const result = await platform.function().run("myFunction", {input: { foo: "bar" }})
+     */
+    run(id: string, d: {
+        input?: Record<string, any>;
+        query?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+    generateSignature(ref: string, env: string): Promise<import("axios").AxiosResponse<any, any>>;
+}

package/dist/v0.9/api/index.d.ts

@@ -0,0 +1,24 @@
+export { default as Component } from './component';
+export { default as Platform } from './platform';
+export { default as Functions } from './functions';
+export { default as APIUser } from './apiUser';
+export { default as Users } from './users';
+export { default as Apps } from './apps';
+export { default as ComponentUtils } from './componentUtils';
+export { default as Thunder } from './thunder';
+export { default as Ratchet } from './ratchet';
+export { default as Sandbox } from './sandbox';
+export { default as System } from './system';
+export { default as Workflow } from './workflow';
+export { default as Forge } from './forge';
+export { default as Project } from './project';
+export { default as Config } from './config';
+export { default as Integrations } from './integrations';
+export { default as Integration } from './integrations';
+export { default as Payments } from './integrations/payments';
+export { default as Invoicing } from './integrations/invoicing';
+export { default as DMS } from './integrations/dms';
+export { default as SerbiaUtil } from './integrations/serbiaUtil';
+export { default as VPFR } from './integrations/vpfr';
+import Platfrom from './platform';
+export default Platfrom;

package/dist/v0.9/api/integrations/dms.d.ts

@@ -0,0 +1,419 @@
+import IntegrationsBaseClient from "../integrationsBaseClient";
+import { AxiosResponse } from "axios";
+import { PDFFillOptions, DataConversionParams, DataValidationParams, DataInfoParams, DataInfo, DataValidationResult, ConversionOptions, HTML2PDFOptions } from "../../types/integrations";
+/**
+ * Document Management System (DMS) API client
+ *
+ * Provides comprehensive document and media management capabilities including:
+ * - File upload, download, and management
+ * - PDF generation and form filling
+ * - Data conversion between JSON, CSV, and Excel formats
+ * - Media processing and EXIF data extraction
+ *
+ * ## Data Conversion Features
+ *
+ * The DMS class includes powerful data conversion capabilities that allow you to:
+ * - Convert between JSON, CSV, and Excel (.xlsx) formats
+ * - Handle structured data with header, items, and footer sections
+ * - Auto-detect structured patterns in JSON arrays
+ * - Validate data format integrity
+ * - Analyze data structure and metadata
+ * - Handle large datasets with memory-efficient processing
+ *
+ * ### Supported Formats
+ * - **JSON**: Array of objects (recommended for tabular data) or structured objects
+ * - **CSV**: Comma-separated values with headers and optional comments
+ * - **Excel**: .xlsx format with optional sheet specification
+ *
+ * ### Structured Data Support
+ * When converting from JSON, the API supports:
+ *
+ * **Explicit Structure**: JSON with dedicated sections
+ * ```json
+ * {
+ *   "header": { "content": { "title": "Report" } },
+ *   "items": [{ "name": "Data" }],
+ *   "footer": { "content": { "total": 100 } }
+ * }
+ * ```
+ *
+ * **Auto-Detection**: Mixed arrays with metadata and summary objects
+ * ```json
+ * [
+ *   { "metadata": "Header info" },
+ *   { "name": "John", "age": 30 },
+ *   { "summary": "Footer info" }
+ * ]
+ * ```
+ *
+ * ### Error Handling
+ * All conversion methods may throw errors with code 3003 for conversion failures.
+ * Always wrap calls in try-catch blocks for production use.
+ *
+ * @example
+ * ```typescript
+ * import { DMS } from 'protokol-sdk';
+ *
+ * const dms = new DMS({
+ *   token: 'your-bearer-token',
+ *   host: 'http://localhost:8086'
+ * });
+ *
+ * const libraryRef = 'your-library-uuid';
+ *
+ * // Convert structured JSON to CSV with comments
+ * const structuredData = {
+ *   header: { content: { title: "Sales Report" } },
+ *   items: [{ product: "Widget", sales: 100 }],
+ *   footer: { content: { total: 100 } }
+ * };
+ *
+ * try {
+ *   const csvResult = await dms.convertData(libraryRef, structuredData, {
+ *     from: 'json',
+ *     to: 'csv',
+ *     header_as_comment: true
+ *   });
+ *   console.log(csvResult.data); // CSV with header as comments
+ * } catch (error) {
+ *   console.error('Conversion failed:', error.message);
+ * }
+ * ```
+ */
+export default class DMS extends IntegrationsBaseClient {
+    list(data: any): Promise<AxiosResponse<any, any>>;
+    libraries(): Promise<AxiosResponse<any, any>>;
+    upload(payload: any): Promise<AxiosResponse<any, any> | undefined>;
+    delete(data: any): Promise<AxiosResponse<any, any>>;
+    uploadBase64(data: any): Promise<AxiosResponse<any, any>>;
+    getMedia(lib: string, key: string, encoding: string): Promise<AxiosResponse<any, any>>;
+    download(lib: string, key: string): Promise<AxiosResponse<any, any>>;
+    getExifData(lib: string, key: string): Promise<AxiosResponse<any, any>>;
+    html2pdf(lib: string, data: HTML2PDFOptions): Promise<AxiosResponse<any, any>>;
+    createDir(lib: string, path: string): Promise<AxiosResponse<any, any>>;
+    deleteDir(lib: string, path: string): Promise<AxiosResponse<any, any>>;
+    dirs(lib: string, data: string): Promise<AxiosResponse<any, any>>;
+    fillPdf(lib: string, data: PDFFillOptions): Promise<AxiosResponse<any, any>>;
+    /**
+     * Convert data between different formats (JSON, CSV, Excel)
+     *
+     * Supports structured data when converting from JSON format with:
+     * - Explicit structure: JSON with `header`, `items`, and `footer` properties
+     * - Auto-detection: Mixed JSON arrays with metadata objects and summary rows
+     *
+     * @param lib - Library reference UUID
+     * @param data - Raw data to convert
+     * @param params - Conversion parameters including structured data options
+     * @returns Promise resolving to converted data
+     *
+     * @example
+     * ```typescript
+     * // Convert JSON to CSV
+     * const jsonData = [
+     *   { name: "John Doe", age: 30, email: "john@example.com" },
+     *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+     * ];
+     *
+     * const csvResult = await dms.convertData(libraryRef, jsonData, {
+     *   from: 'json',
+     *   to: 'csv'
+     * });
+     * console.log(csvResult.data); // CSV string
+     *
+     * // Convert structured JSON with header as comments
+     * const structuredData = {
+     *   header: {
+     *     content: {
+     *       report_title: "Monthly Sales Report",
+     *       generated_by: "Sales System"
+     *     }
+     *   },
+     *   items: [
+     *     { product: "Widget A", sales: 100 },
+     *     { product: "Widget B", sales: 150 }
+     *   ],
+     *   footer: {
+     *     content: {
+     *       total_sales: 250
+     *     }
+     *   }
+     * };
+     *
+     * const csvWithComments = await dms.convertData(libraryRef, structuredData, {
+     *   from: 'json',
+     *   to: 'csv',
+     *   header_as_comment: true,
+     *   separator_rows: 2
+     * });
+     *
+     * // Convert JSON to Excel with custom sheet name
+     * const excelResult = await dms.convertData(libraryRef, jsonData, {
+     *   from: 'json',
+     *   to: 'excel',
+     *   sheet_name: 'Customer Data'
+     * });
+     * // excelResult.data is a Blob
+     * ```
+     */
+    convertData(lib: string, data: any, params: DataConversionParams): Promise<AxiosResponse<any>>;
+    /**
+     * Get information about data format and structure
+     *
+     * @param lib - Library reference UUID
+     * @param data - Raw data to analyze
+     * @param params - Analysis parameters
+     * @returns Promise resolving to data information
+     *
+     * @example
+     * ```typescript
+     * const jsonData = [
+     *   { name: "John", age: 30, email: "john@example.com" },
+     *   { name: "Jane", age: 25, email: "jane@example.com" }
+     * ];
+     *
+     * const dataInfo = await dms.getDataInfo(libraryRef, jsonData, {
+     *   format: 'json'
+     * });
+     *
+     * console.log(dataInfo.data);
+     * // Output:
+     * // {
+     * //   format: "json",
+     * //   size_bytes: 245,
+     * //   record_count: 2,
+     * //   field_count: 3,
+     * //   fields: ["name", "age", "email"],
+     * //   library_ref: "98bee1cb-0f21-4582-a832-7c32b4b61831"
+     * // }
+     * ```
+     */
+    getDataInfo(lib: string, data: any, params: DataInfoParams): Promise<AxiosResponse<DataInfo>>;
+    /**
+     * Validate data format without performing conversion
+     *
+     * @param lib - Library reference UUID
+     * @param data - Raw data to validate
+     * @param params - Validation parameters
+     * @returns Promise resolving to validation result
+     *
+     * @example
+     * ```typescript
+     * const jsonData = [{ name: "John", age: 30 }];
+     *
+     * const validation = await dms.validateData(libraryRef, jsonData, {
+     *   format: 'json'
+     * });
+     *
+     * console.log(validation.data);
+     * // Output:
+     * // {
+     * //   valid: true,
+     * //   message: "Data is valid JSON format",
+     * //   library_ref: "98bee1cb-0f21-4582-a832-7c32b4b61831"
+     * // }
+     *
+     * // Handle invalid data
+     * try {
+     *   const invalidValidation = await dms.validateData(libraryRef, "invalid json", {
+     *     format: 'json'
+     *   });
+     * } catch (error) {
+     *   console.error('Validation failed:', error.response?.data?.message);
+     * }
+     * ```
+     */
+    validateData(lib: string, data: any, params: DataValidationParams): Promise<AxiosResponse<DataValidationResult>>;
+    /**
+     * Convert JSON data to CSV format
+     *
+     * This method supports both regular JSON arrays and structured data with auto-detection:
+     * - Regular arrays are converted directly to CSV
+     * - Structured data (with metadata objects) is automatically detected and formatted
+     *
+     * @param lib - Library reference UUID
+     * @param jsonData - JSON data (array of objects or structured data)
+     * @returns Promise resolving to CSV string
+     *
+     * @example
+     * ```typescript
+     * // Regular JSON to CSV
+     * const jsonData = [
+     *   { name: "John Doe", age: 30, email: "john@example.com" },
+     *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+     * ];
+     *
+     * const csvResponse = await dms.jsonToCsv(libraryRef, jsonData);
+     * console.log(csvResponse.data);
+     * // Output:
+     * // name,age,email
+     * // John Doe,30,john@example.com
+     * // Jane Smith,25,jane@example.com
+     *
+     * // Structured JSON with auto-detection
+     * const structuredData = [
+     *   { metadata: "EMPLOYEE REPORT\nGenerated: 2025-10-08" },
+     *   { name: "John Doe", age: 30, position: "Developer" },
+     *   { name: "Jane Smith", age: 25, position: "Designer" },
+     *   { name: "Total Employees:", age: null, position: "2 people" }
+     * ];
+     *
+     * const structuredCsv = await dms.jsonToCsv(libraryRef, structuredData);
+     * // Auto-detects header, items, and footer sections
+     * ```
+     */
+    jsonToCsv(lib: string, jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<string>>;
+    /**
+     * Convert JSON data to Excel (.xlsx) format
+     *
+     * Supports both regular JSON arrays and structured data patterns.
+     * Excel files are always generated with .xlsx extension.
+     *
+     * @param lib - Library reference UUID
+     * @param jsonData - JSON data (array of objects or structured data)
+     * @param options - Optional conversion options
+     * @returns Promise resolving to Excel file as Blob
+     *
+     * @example
+     * ```typescript
+     * // Regular JSON to Excel
+     * const jsonData = [
+     *   { name: "John Doe", age: 30, email: "john@example.com" },
+     *   { name: "Jane Smith", age: 25, email: "jane@example.com" }
+     * ];
+     *
+     * // Basic conversion
+     * const excelResponse = await dms.jsonToExcel(libraryRef, jsonData);
+     * const blob = excelResponse.data; // Blob for download
+     *
+     * // With custom sheet name
+     * const excelWithOptions = await dms.jsonToExcel(libraryRef, jsonData, {
+     *   sheet_name: 'Customer Data'
+     * });
+     *
+     * // Structured data with explicit sections
+     * const structuredData = {
+     *   header: { content: { title: "Monthly Report" } },
+     *   items: [{ product: "Widget A", sales: 100 }],
+     *   footer: { content: { total_sales: 100 } }
+     * };
+     *
+     * const structuredExcel = await dms.jsonToExcel(libraryRef, structuredData);
+     *
+     * // Create download link
+     * const url = URL.createObjectURL(structuredExcel.data);
+     * const link = document.createElement('a');
+     * link.href = url;
+     * link.download = 'report.xlsx'; // Always .xlsx extension
+     * link.click();
+     * ```
+     */
+    jsonToExcel(lib: string, jsonData: any, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
+    /**
+     * Convert CSV data to JSON format
+     *
+     * @param lib - Library reference UUID
+     * @param csvData - CSV data string (with headers in first row)
+     * @returns Promise resolving to JSON array
+     *
+     * @example
+     * ```typescript
+     * const csvString = `name,age,email
+     * John Doe,30,john@example.com
+     * Jane Smith,25,jane@example.com`;
+     *
+     * const jsonResponse = await dms.csvToJson(libraryRef, csvString);
+     * console.log(jsonResponse.data);
+     * // Output:
+     * // [
+     * //   { name: "John Doe", age: "30", email: "john@example.com" },
+     * //   { name: "Jane Smith", age: "25", email: "jane@example.com" }
+     * // ]
+     * ```
+     */
+    csvToJson(lib: string, csvData: string): Promise<AxiosResponse<any[]>>;
+    /**
+     * Convert CSV data to Excel (.xlsx) format
+     *
+     * @param lib - Library reference UUID
+     * @param csvData - CSV data string (with headers in first row)
+     * @param options - Optional conversion options
+     * @returns Promise resolving to Excel file as Blob
+     *
+     * @example
+     * ```typescript
+     * const csvString = `name,age,email
+     * John Doe,30,john@example.com
+     * Jane Smith,25,jane@example.com`;
+     *
+     * const excelResponse = await dms.csvToExcel(libraryRef, csvString, {
+     *   sheet_name: 'Imported Data'
+     * });
+     *
+     * // Handle the Excel blob
+     * const blob = excelResponse.data;
+     * const url = URL.createObjectURL(blob);
+     * // Use url for download or further processing
+     * ```
+     */
+    csvToExcel(lib: string, csvData: string, options?: ConversionOptions): Promise<AxiosResponse<Blob>>;
+    /**
+     * Convert Excel (.xlsx) data to JSON format
+     *
+     * @param lib - Library reference UUID
+     * @param excelData - Excel file data as Blob or ArrayBuffer
+     * @param options - Optional conversion options
+     * @returns Promise resolving to JSON array
+     *
+     * @example
+     * ```typescript
+     * // From file input
+     * const fileInput = document.querySelector('input[type="file"]');
+     * const file = fileInput.files[0]; // Excel file
+     *
+     * const jsonResponse = await dms.excelToJson(libraryRef, file, {
+     *   sheet_name: 'Sheet1' // optional, defaults to first sheet
+     * });
+     *
+     * console.log(jsonResponse.data);
+     * // Output: JSON array with data from Excel sheet
+     *
+     * // From ArrayBuffer
+     * const arrayBuffer = await file.arrayBuffer();
+     * const jsonFromBuffer = await dms.excelToJson(libraryRef, arrayBuffer);
+     * ```
+     */
+    excelToJson(lib: string, excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<any[]>>;
+    /**
+     * Convert Excel (.xlsx) data to CSV format
+     *
+     * @param lib - Library reference UUID
+     * @param excelData - Excel file data as Blob or ArrayBuffer
+     * @param options - Optional conversion options
+     * @returns Promise resolving to CSV string
+     *
+     * @example
+     * ```typescript
+     * // From file input
+     * const fileInput = document.querySelector('input[type="file"]');
+     * const file = fileInput.files[0]; // Excel file
+     *
+     * const csvResponse = await dms.excelToCsv(libraryRef, file, {
+     *   sheet_name: 'Data' // optional, defaults to first sheet
+     * });
+     *
+     * console.log(csvResponse.data);
+     * // Output: CSV string with data from Excel sheet
+     *
+     * // Save as CSV file
+     * const csvBlob = new Blob([csvResponse.data], { type: 'text/csv' });
+     * const url = URL.createObjectURL(csvBlob);
+     * const link = document.createElement('a');
+     * link.href = url;
+     * link.download = 'converted.csv';
+     * link.click();
+     * ```
+     */
+    excelToCsv(lib: string, excelData: Blob | ArrayBuffer, options?: ConversionOptions): Promise<AxiosResponse<string>>;
+    request(method: string, endpoint: string, params?: any): Promise<AxiosResponse<any, any>>;
+    requestv1(method: string, endpoint: string, params?: any): Promise<AxiosResponse<any, any>>;
+}

package/dist/v0.9/api/integrations/invoicing.d.ts

@@ -0,0 +1,6 @@
+import PlatformBaseClient from "../platformBaseClient";
+export default class Invoicing extends PlatformBaseClient {
+    getSalesInvoices(provider: string, page: number): Promise<import("axios").AxiosResponse<any, any>>;
+    acceptPurchaseInvoice(provider: string, id: string, comment: string): Promise<import("axios").AxiosResponse<any, any>>;
+    request(method: string, endpoint: string, params: any): Promise<import("axios").AxiosResponse<any, any>>;
+}