@giveitsmaller/sdk 0.1.1 → 0.2.0

package/dist/client.d.ts

@@ -0,0 +1,55 @@
+import type { UploadResponse, WorkflowCreateResponse, WorkflowStatusResponse, WorkflowDownloadResponse, MetadataResponse, OperationsSchemaResponse, RetryResponse } from '@giveitsmaller/contracts/openapi';
+import type { GislClientConfig, GislSseEvent, UploadOptions, WaitOptions, WorkflowCreatePayload } from './types.js';
+export declare class GislClient {
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly timeoutMs;
+    private readonly multipartThreshold;
+    private readonly multipartConcurrency;
+    constructor(config: GislClientConfig);
+    private request;
+    private handleResponse;
+    /**
+     * Upload a file. Automatically uses multipart upload for files exceeding
+     * the configured threshold (default 10 MB).
+     *
+     * @param file  File path (string) or a Blob/File instance.
+     * @param options  Upload options including progress callback.
+     */
+    uploadFile(file: string | Blob, options?: UploadOptions): Promise<UploadResponse>;
+    private singleUpload;
+    private multipartUpload;
+    /**
+     * Create a new workflow.
+     */
+    createWorkflow(payload: WorkflowCreatePayload): Promise<WorkflowCreateResponse>;
+    /**
+     * Get current workflow status.
+     */
+    getWorkflowStatus(workflowId: string): Promise<WorkflowStatusResponse>;
+    /**
+     * Poll until the workflow reaches a terminal status.
+     */
+    waitForWorkflow(workflowId: string, options?: WaitOptions): Promise<WorkflowStatusResponse>;
+    /**
+     * Get download URLs for a completed workflow.
+     */
+    getWorkflowDownloads(workflowId: string): Promise<WorkflowDownloadResponse>;
+    /**
+     * Stream SSE events for a workflow. Returns an async iterable.
+     */
+    streamEvents(workflowId: string): Promise<AsyncGenerator<GislSseEvent>>;
+    /**
+     * Get metadata for an uploaded file.
+     */
+    getMetadata(fileId: string): Promise<MetadataResponse>;
+    /**
+     * Get the operations schema (available types, options, constraints).
+     * This endpoint returns raw JSON (no envelope) and is CDN-cacheable.
+     */
+    getSchema(): Promise<OperationsSchemaResponse>;
+    /**
+     * Retry a failed operation.
+     */
+    retryOperation(operationId: string): Promise<RetryResponse>;
+}

package/dist/client.js

@@ -0,0 +1,284 @@
+import { readFileSync, statSync } from 'node:fs';
+import { basename } from 'node:path';
+import { UploadResponseFromJSON, MultipartInitiateResponseFromJSON, WorkflowCreateResponseFromJSON, WorkflowStatusResponseFromJSON, WorkflowDownloadResponseFromJSON, MetadataResponseFromJSON, OperationsSchemaResponseFromJSON, RetryResponseFromJSON, WorkflowStatus, } from '@giveitsmaller/contracts/openapi';
+import { GislApiError, GislError, GislTimeoutError, GislValidationError } from './errors.js';
+import { parseSseStream } from './sse.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MULTIPART_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+const DEFAULT_MULTIPART_CONCURRENCY = 4;
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_POLL_TIMEOUT_MS = 300_000; // 5 min
+const TERMINAL_STATUSES = new Set([
+    WorkflowStatus.completed,
+    WorkflowStatus.failed,
+    WorkflowStatus.partially_failed,
+]);
+export class GislClient {
+    baseUrl;
+    headers;
+    timeoutMs;
+    multipartThreshold;
+    multipartConcurrency;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/+$/, '');
+        this.timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.multipartThreshold = config.multipartThreshold ?? DEFAULT_MULTIPART_THRESHOLD;
+        this.multipartConcurrency = config.multipartConcurrency ?? DEFAULT_MULTIPART_CONCURRENCY;
+        this.headers = { ...config.headers };
+        if (config.apiKey) {
+            this.headers['Authorization'] = `Bearer ${config.apiKey}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Internal HTTP
+    // -----------------------------------------------------------------------
+    async request(method, path, opts = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = { ...this.headers };
+        let body;
+        if (opts.json !== false && opts.body && !(opts.body instanceof FormData)) {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(opts.body);
+        }
+        else {
+            body = opts.body;
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers,
+                body,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                throw new GislTimeoutError(`Request to ${method} ${path} timed out after ${this.timeoutMs}ms`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (opts.rawResponse) {
+            return response;
+        }
+        return this.handleResponse(response, path, opts.deserialize);
+    }
+    async handleResponse(response, path, deserialize) {
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes('application/json')) {
+            if (!response.ok) {
+                throw new GislApiError(response.status, `Non-JSON error from ${path}`);
+            }
+            return undefined;
+        }
+        const json = await response.json();
+        // Schema endpoint returns raw JSON (no envelope)
+        if (path === '/api/operations/schema') {
+            if (!response.ok) {
+                throw new GislApiError(response.status, json.error ?? 'Unknown error');
+            }
+            return deserialize ? deserialize(json) : json;
+        }
+        // Standard envelope: { success, data } or { success, error, details }
+        if (!response.ok || json.success === false) {
+            if (json.details && Array.isArray(json.details)) {
+                throw new GislValidationError(response.status, json.error ?? 'Validation error', json.details);
+            }
+            throw new GislApiError(response.status, json.error ?? 'Unknown error');
+        }
+        const data = json.data ?? json;
+        return deserialize ? deserialize(data) : data;
+    }
+    // -----------------------------------------------------------------------
+    // Upload
+    // -----------------------------------------------------------------------
+    /**
+     * Upload a file. Automatically uses multipart upload for files exceeding
+     * the configured threshold (default 10 MB).
+     *
+     * @param file  File path (string) or a Blob/File instance.
+     * @param options  Upload options including progress callback.
+     */
+    async uploadFile(file, options) {
+        let blob;
+        let fileName;
+        let fileSize;
+        if (typeof file === 'string') {
+            const stat = statSync(file);
+            fileSize = stat.size;
+            fileName = basename(file);
+            const content = readFileSync(file);
+            blob = new Blob([content]);
+        }
+        else {
+            blob = file;
+            fileName = file.name ?? 'upload';
+            fileSize = file.size;
+        }
+        if (fileSize > this.multipartThreshold) {
+            return this.multipartUpload(blob, fileName, fileSize, options);
+        }
+        return this.singleUpload(blob, fileName);
+    }
+    async singleUpload(blob, fileName) {
+        const form = new FormData();
+        form.append('file', blob, fileName);
+        return this.request('POST', '/api/uploads', {
+            body: form,
+            json: false,
+            deserialize: UploadResponseFromJSON,
+        });
+    }
+    async multipartUpload(blob, fileName, totalSize, options) {
+        // Step 1: Initiate with first chunk
+        const firstChunkSize = Math.min(totalSize, this.multipartThreshold);
+        const firstChunk = blob.slice(0, firstChunkSize);
+        const initiateForm = new FormData();
+        initiateForm.append('chunk', firstChunk, fileName);
+        initiateForm.append('original_name', fileName);
+        initiateForm.append('total_size_bytes', totalSize.toString());
+        const initResponse = await this.request('POST', '/api/uploads/multipart/initiate', {
+            body: initiateForm,
+            json: false,
+            deserialize: MultipartInitiateResponseFromJSON,
+        });
+        let uploadedBytes = firstChunkSize;
+        options?.onProgress?.(uploadedBytes, totalSize);
+        // Step 2: Upload remaining chunks to S3 presigned URLs
+        const etags = [];
+        const presignedUrls = initResponse.presignedUrls;
+        const chunkSize = initResponse.recommendedChunkSize;
+        const uploadChunk = async (index) => {
+            const part = presignedUrls[index];
+            const start = firstChunkSize + index * chunkSize;
+            const end = Math.min(start + chunkSize, totalSize);
+            const chunk = blob.slice(start, end);
+            const s3Response = await fetch(part.url, {
+                method: 'PUT',
+                body: chunk,
+                headers: { 'Content-Length': (end - start).toString() },
+            });
+            if (!s3Response.ok) {
+                throw new GislError(`S3 chunk upload failed for part ${part.partNumber}: ${s3Response.status}`);
+            }
+            const etag = s3Response.headers.get('etag');
+            if (!etag) {
+                throw new GislError(`S3 response missing ETag for part ${part.partNumber}`);
+            }
+            etags.push({ part_number: part.partNumber, etag });
+            uploadedBytes += end - start;
+            options?.onProgress?.(uploadedBytes, totalSize);
+        };
+        // Upload with concurrency limit
+        const queue = [...presignedUrls.keys()];
+        const workers = Array.from({ length: Math.min(this.multipartConcurrency, queue.length) }, async () => {
+            while (queue.length > 0) {
+                const index = queue.shift();
+                await uploadChunk(index);
+            }
+        });
+        await Promise.all(workers);
+        // Step 3: Complete multipart upload
+        etags.sort((a, b) => a.part_number - b.part_number);
+        return this.request('POST', '/api/uploads/multipart/complete', {
+            body: {
+                file_id: initResponse.fileId,
+                parts: etags,
+            },
+            deserialize: UploadResponseFromJSON,
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Workflows
+    // -----------------------------------------------------------------------
+    /**
+     * Create a new workflow.
+     */
+    async createWorkflow(payload) {
+        return this.request('POST', '/api/workflows', {
+            body: payload,
+            deserialize: WorkflowCreateResponseFromJSON,
+        });
+    }
+    /**
+     * Get current workflow status.
+     */
+    async getWorkflowStatus(workflowId) {
+        return this.request('GET', `/api/workflows/${encodeURIComponent(workflowId)}/status`, {
+            deserialize: WorkflowStatusResponseFromJSON,
+        });
+    }
+    /**
+     * Poll until the workflow reaches a terminal status.
+     */
+    async waitForWorkflow(workflowId, options) {
+        const intervalMs = options?.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+            const status = await this.getWorkflowStatus(workflowId);
+            options?.onPoll?.(status.status);
+            if (TERMINAL_STATUSES.has(status.status)) {
+                return status;
+            }
+            if (Date.now() + intervalMs > deadline) {
+                throw new GislTimeoutError(`Workflow ${workflowId} did not complete within ${timeoutMs}ms`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    /**
+     * Get download URLs for a completed workflow.
+     */
+    async getWorkflowDownloads(workflowId) {
+        return this.request('GET', `/api/workflows/${encodeURIComponent(workflowId)}/download`, {
+            deserialize: WorkflowDownloadResponseFromJSON,
+        });
+    }
+    /**
+     * Stream SSE events for a workflow. Returns an async iterable.
+     */
+    async streamEvents(workflowId) {
+        const response = await this.request('GET', `/api/workflows/${encodeURIComponent(workflowId)}/events`, { rawResponse: true });
+        if (!response.ok) {
+            await this.handleResponse(response, `/api/workflows/${workflowId}/events`);
+        }
+        return parseSseStream(response);
+    }
+    // -----------------------------------------------------------------------
+    // File metadata
+    // -----------------------------------------------------------------------
+    /**
+     * Get metadata for an uploaded file.
+     */
+    async getMetadata(fileId) {
+        return this.request('GET', `/api/uploads/${encodeURIComponent(fileId)}/metadata`, {
+            deserialize: MetadataResponseFromJSON,
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Operations
+    // -----------------------------------------------------------------------
+    /**
+     * Get the operations schema (available types, options, constraints).
+     * This endpoint returns raw JSON (no envelope) and is CDN-cacheable.
+     */
+    async getSchema() {
+        return this.request('GET', '/api/operations/schema', {
+            deserialize: OperationsSchemaResponseFromJSON,
+        });
+    }
+    /**
+     * Retry a failed operation.
+     */
+    async retryOperation(operationId) {
+        return this.request('POST', `/api/operations/${encodeURIComponent(operationId)}/retry`, {
+            deserialize: RetryResponseFromJSON,
+        });
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class GislError extends Error {
+    constructor(message: string);
+}
+export declare class GislApiError extends GislError {
+    readonly statusCode: number;
+    readonly errorMessage: string;
+    constructor(statusCode: number, errorMessage: string);
+}
+export declare class GislValidationError extends GislApiError {
+    readonly details: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(statusCode: number, errorMessage: string, details: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+export declare class GislTimeoutError extends GislError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,30 @@
+export class GislError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GislError';
+    }
+}
+export class GislApiError extends GislError {
+    statusCode;
+    errorMessage;
+    constructor(statusCode, errorMessage) {
+        super(`API error ${statusCode}: ${errorMessage}`);
+        this.name = 'GislApiError';
+        this.statusCode = statusCode;
+        this.errorMessage = errorMessage;
+    }
+}
+export class GislValidationError extends GislApiError {
+    details;
+    constructor(statusCode, errorMessage, details) {
+        super(statusCode, errorMessage);
+        this.name = 'GislValidationError';
+        this.details = details;
+    }
+}
+export class GislTimeoutError extends GislError {
+    constructor(message) {
+        super(message);
+        this.name = 'GislTimeoutError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { GislClient } from './client.js';
+export { verifyWebhook } from './webhook.js';
+export { parseSseStream } from './sse.js';
+export type { GislClientConfig, GislSseEvent, UploadOptions, WaitOptions, WorkflowCreatePayload, OperationDef, FileJobPayload, SourceJobPayload, InputsJobPayload, JobDefinitionPayload, } from './types.js';
+export { fileJob, sourceJob, inputsJob } from './types.js';
+export { GislError, GislApiError, GislValidationError, GislTimeoutError, } from './errors.js';
+export type { UploadResponse, WorkflowCreateResponse, WorkflowStatusResponse, WorkflowDownloadResponse, MetadataResponse, OperationsSchemaResponse, RetryResponse, JobDownload, OperationDownload, WebhookPayload, JobResponse, OperationResponse, OperationResult, ExportConfig, } from '@giveitsmaller/contracts/openapi';
+export { WorkflowStatus, OperationType, SseEventType, CallbackEventType, OperationStatus, JobStatus, } from '@giveitsmaller/contracts/openapi';
+export type { SseOperationProgressData, SseOperationCompletedData, SseOperationFailedData, SseJobCompletedData, SseJobFailedData, SseWorkflowTerminalData, } from '@giveitsmaller/contracts/openapi';
+export type { CompressImageOptions, CompressVideoOptions, CompressAudioOptions, CompressDocumentPdfOptions, CompressDocumentOfficeOptions, CompressDocumentOdfOptions, CompressDocumentEpubOptions, ThumbnailImageOptions, ThumbnailVideoOptions, ThumbnailDocumentOptions, ConvertImageOptions, ConvertVideoOptions, ConvertAudioOptions, ConvertDocumentPdfOptions, MergeImageOptions, MergeVideoOptions, MergeAudioOptions, MergeDocumentOptions, ArchiveOptions, } from '@giveitsmaller/contracts/operations';

package/dist/index.js

@@ -0,0 +1,8 @@
+// SDK classes and functions
+export { GislClient } from './client.js';
+export { verifyWebhook } from './webhook.js';
+export { parseSseStream } from './sse.js';
+export { fileJob, sourceJob, inputsJob } from './types.js';
+// Errors
+export { GislError, GislApiError, GislValidationError, GislTimeoutError, } from './errors.js';
+export { WorkflowStatus, OperationType, SseEventType, CallbackEventType, OperationStatus, JobStatus, } from '@giveitsmaller/contracts/openapi';

package/dist/sse.d.ts

@@ -0,0 +1,11 @@
+import type { GislSseEvent } from './types.js';
+/**
+ * Parse an SSE stream from a fetch Response into an AsyncIterable of typed events.
+ *
+ * Handles:
+ * - Chunk boundary buffering (events split across chunks)
+ * - Multi-line `data:` fields (concatenated with newlines)
+ * - Comment lines (`:` prefix) used as keep-alives
+ * - `retry:` field (ignored, SDK manages its own reconnection)
+ */
+export declare function parseSseStream(response: Response): AsyncGenerator<GislSseEvent>;

package/dist/sse.js

@@ -0,0 +1,95 @@
+/**
+ * Parse an SSE stream from a fetch Response into an AsyncIterable of typed events.
+ *
+ * Handles:
+ * - Chunk boundary buffering (events split across chunks)
+ * - Multi-line `data:` fields (concatenated with newlines)
+ * - Comment lines (`:` prefix) used as keep-alives
+ * - `retry:` field (ignored, SDK manages its own reconnection)
+ */
+export async function* parseSseStream(response) {
+    const body = response.body;
+    if (!body) {
+        return;
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let eventType = '';
+    let dataLines = [];
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            // SSE spec allows \n, \r\n, and \r as line endings
+            const lines = buffer.replace(/\r\n?/g, '\n').split('\n');
+            // Keep the last (potentially incomplete) line in the buffer
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line === '') {
+                    // Empty line = end of event
+                    if (dataLines.length > 0) {
+                        const rawData = dataLines.join('\n');
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(rawData);
+                        }
+                        catch {
+                            parsed = rawData;
+                        }
+                        yield {
+                            event: eventType || 'message',
+                            data: parsed,
+                        };
+                    }
+                    eventType = '';
+                    dataLines = [];
+                    continue;
+                }
+                if (line.startsWith(':')) {
+                    // Comment line (keep-alive), skip
+                    continue;
+                }
+                const colonIndex = line.indexOf(':');
+                if (colonIndex === -1) {
+                    continue;
+                }
+                const field = line.slice(0, colonIndex);
+                // Strip single leading space after colon per SSE spec
+                const valueStart = line[colonIndex + 1] === ' ' ? colonIndex + 2 : colonIndex + 1;
+                const fieldValue = line.slice(valueStart);
+                switch (field) {
+                    case 'event':
+                        eventType = fieldValue;
+                        break;
+                    case 'data':
+                        dataLines.push(fieldValue);
+                        break;
+                    case 'retry':
+                        // Ignored — SDK manages its own polling/reconnection
+                        break;
+                }
+            }
+        }
+        // Flush any remaining buffered event
+        if (dataLines.length > 0) {
+            const rawData = dataLines.join('\n');
+            let parsed;
+            try {
+                parsed = JSON.parse(rawData);
+            }
+            catch {
+                parsed = rawData;
+            }
+            yield {
+                event: eventType || 'message',
+                data: parsed,
+            };
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+import type { OperationType, CallbackEventType, SseEventType, SseOperationProgressData, SseOperationCompletedData, SseOperationFailedData, SseJobCompletedData, SseJobFailedData, SseWorkflowTerminalData } from '@giveitsmaller/contracts/openapi';
+export interface GislClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    /** Threshold in bytes above which multipart upload is used (default: 10MB) */
+    multipartThreshold?: number;
+    /** Max concurrent chunk uploads for multipart (default: 4) */
+    multipartConcurrency?: number;
+}
+export interface OperationDef {
+    type: OperationType;
+    options?: Record<string, unknown>;
+}
+/** Job sourced from an uploaded file */
+export interface FileJobPayload {
+    ref: string;
+    file_id: string;
+    operations: OperationDef[];
+}
+/** Job sourced from a single upstream job's output */
+export interface SourceJobPayload {
+    ref: string;
+    source: {
+        ref: string;
+        operation?: string;
+    };
+    operations: OperationDef[];
+}
+/** Job sourced from multiple upstream jobs (merge/archive) */
+export interface InputsJobPayload {
+    ref: string;
+    inputs: Array<{
+        ref: string;
+        operation?: string;
+        per_input_options?: Record<string, unknown>;
+    }>;
+    operations: OperationDef[];
+}
+export type JobDefinitionPayload = FileJobPayload | SourceJobPayload | InputsJobPayload;
+export declare function fileJob(ref: string, fileId: string, operations: OperationDef[]): FileJobPayload;
+export declare function sourceJob(ref: string, source: {
+    ref: string;
+    operation?: string;
+}, operations: OperationDef[]): SourceJobPayload;
+export declare function inputsJob(ref: string, inputs: Array<{
+    ref: string;
+    operation?: string;
+    per_input_options?: Record<string, unknown>;
+}>, operations: OperationDef[]): InputsJobPayload;
+export interface WorkflowCreatePayload {
+    jobs: JobDefinitionPayload[];
+    workflow_edges?: Array<{
+        from: string;
+        to: string;
+    }>;
+    callback_url?: string;
+    callback_events?: CallbackEventType[];
+    export?: {
+        service: 's3';
+        bucket: string;
+        key_prefix?: string;
+        role_arn: string;
+    };
+}
+export interface WaitOptions {
+    /** Poll interval in milliseconds (default: 2000) */
+    intervalMs?: number;
+    /** Maximum wait time in milliseconds (default: 300000 = 5 min) */
+    timeoutMs?: number;
+    /** Called after each poll with current status */
+    onPoll?: (status: string) => void;
+}
+export type GislSseEvent = {
+    event: typeof SseEventType.operation_progress;
+    data: SseOperationProgressData;
+} | {
+    event: typeof SseEventType.operation_completed;
+    data: SseOperationCompletedData;
+} | {
+    event: typeof SseEventType.operation_failed;
+    data: SseOperationFailedData;
+} | {
+    event: typeof SseEventType.job_completed;
+    data: SseJobCompletedData;
+} | {
+    event: typeof SseEventType.job_failed;
+    data: SseJobFailedData;
+} | {
+    event: typeof SseEventType.workflow_completed;
+    data: SseWorkflowTerminalData;
+} | {
+    event: typeof SseEventType.workflow_failed;
+    data: SseWorkflowTerminalData;
+} | {
+    event: typeof SseEventType.workflow_partially_failed;
+    data: SseWorkflowTerminalData;
+} | {
+    event: string;
+    data: unknown;
+};
+export interface UploadOptions {
+    /** Called with bytes uploaded so far (only for multipart) */
+    onProgress?: (uploadedBytes: number, totalBytes: number) => void;
+}

package/dist/types.js

@@ -0,0 +1,12 @@
+// ---------------------------------------------------------------------------
+// Job factory functions
+// ---------------------------------------------------------------------------
+export function fileJob(ref, fileId, operations) {
+    return { ref, file_id: fileId, operations };
+}
+export function sourceJob(ref, source, operations) {
+    return { ref, source, operations };
+}
+export function inputsJob(ref, inputs, operations) {
+    return { ref, inputs, operations };
+}

package/dist/webhook.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Verify a GISL webhook signature.
+ *
+ * @param secret   The `webhook_secret` from the workflow creation response.
+ * @param signature The value of the `X-GIS-Signature` header.
+ * @param body     The raw request body as a string or Buffer.
+ * @returns `true` if valid.
+ * @throws {GislError} if the signature is missing, malformed, or invalid.
+ */
+export declare function verifyWebhook(secret: string, signature: string, body: string | Buffer): boolean;