Name	Name	Last commit message	Last commit date
Latest commit History 48 Commits
.github	.github
src	src
tests	tests
.eslintrc.js	.eslintrc.js
.gitignore	.gitignore
.nvmrc	.nvmrc
.prettierrc.js	.prettierrc.js
.releaserc	.releaserc
CHANGELOG.md	CHANGELOG.md
Makefile	Makefile
README.md	README.md
dot.env	dot.env
jest.config.ts	jest.config.ts
package-lock.json	package-lock.json
package.json	package.json
tsconfig.json	tsconfig.json

Overview

alfred-node is a TypeScript/Node.js library that provides a streamlined approach to integrate with Alfred's Intelligent Process Automation platform. It enables developers to manage accounts, process and manipulate data points, handle job creation and management, manage sessions, and handle file operations with ease.

Alfred

Alfred is a powerful document processing platform that enables you to extract, index, and search through large document collections with ease. It offers a wide range of features, including:

Job Management: Provides a robust job management system that allows you to schedule and monitor document processing jobs.
Tagging: Tag documents based on their content, making it easy to organize and search through large document collections.
Extraction: Can extract specific data from PDFs, images, and other documents with ease using its powerful extraction engine.
Indexing: Powerful indexing engine that can index and search through millions of documents in seconds.
Integration: Alfred can be easily integrated into your existing applications using its powerful API and SDKs.
Scalability: Alfred is designed to scale with your needs, whether you're processing thousands of documents a day or millions.

Features

Comprehensive Authentication Support: Seamlessly handles OAuth, HMAC, and API key authentication methods, simplifying the process of connecting to the Alfred API.
Domain-Specific Operations: Offers specialized support for File and Job operations, enabling developers to intuitively manage and interact with API resources.
Cross-Platform Compatibility: Designed to be fully compatible across .NET Core, .NET Standard, and .NET Framework 4.7.2, ensuring broad usability in diverse development environments.
Minimal Dependencies: Crafted to minimize external dependencies, facilitating an easier integration and deployment process with reduced conflict risk.
Real-Time Event Monitoring: Provides an event monitoring system that allows developers to receive real-time updates on Job and File events within the Alfred platform.

Prerequisites

Before you can use the alfred-node library, you need to:

Have an Alfred account. If you don't have one, reach out to TagShelf to get started.
Choose the authentication method that best suits your needs. Please see the authentication section in the official API documentation for more information.
Node.js version 18 or higher.

Installation

To use the alfred-node library, first install it via npm:

npm install @tagshelf/alfred

or using yarn:

yarn add @tagshelf/alfred

Usage

Initialize the Client

Begin by creating an instance of the Alfred client using the desired environment (Production or Staging) along with your preferred authentication method. You can find detailed information about the Alfred Client in the reference section of this document

Environments description

Production: The production environment are used for live applications and real-world scenarios. It is recommended to use this environment for production-ready applications. The frontend URL for the production environment is https://app.tagshelf.com

Staging: The staging environment is used for testing and development purposes. It is recommended to use this environment for testing and development scenarios. The frontend URL for the staging environment is https://staging.tagshelf.com Check out this simple example in TypeScript to get up and running:

Authentication Methods

To obtain the necessary credentials for the following authentication methods, please refer to authentication section in the official API documentation or contact the Alfred support team.

The following examples demonstrate how to initialize the client with different environments and different authentication methods:

For API Key authentication:

import { AlfredClient, Configuration } from "@tagshelf/alfred";

// Choose environment
const config: Configuration = Configuration.default("production");

// Initialize Alfred client with API Key
const client: AlfredClient = new AlfredClient(config, {
    apiKey: "your-api-key",
});

For HMAC authentication:

import { AlfredClient, Configuration } from "@tagshelf/alfred";

// Choose environment
const config: Configuration = Configuration.default("production");

// Initialize Alfred client with HMAC
const client: AlfredClient = new AlfredClient(config, {
    hmac: {
        key: "your-key",
        secret: "your-secret",
    }
});

For OAuth authentication:

import { AlfredClient, Configuration } from "@tagshelf/alfred";

// Choose environment
const config: Configuration = Configuration.default("production");

// Initialize Alfred client with OAuth
const client: AlfredClient = new AlfredClient(config, {
    oauth: {
        username: "your-username",
        password: "your-password",
    }
});

Upload Files

Alfred provides two distinct workflows for uploading files, each suited for different use cases:

Deferred Session Workflow (Binary Upload): Upload files from your local machine using binary/stream data, then manually create a job
Remote Sources Workflow (URL Upload): Upload files from URLs or cloud storage, and a job is automatically created

Upload Files via Deferred Session (Binary Upload)

This workflow is ideal when you have local files (binary data) that need to be uploaded. The process involves three steps:

Step 1: Create a Deferred Session

First, create a deferred session to get a session ID that will link your files together.

import { AlfredClient, Configuration, CreateSessionResult } from "@tagshelf/alfred";

// ... Initialization code here ...

// Step 1: Create a deferred session
const session: CreateSessionResult = await client.sessions.create();
console.log("Session ID:", session.sessionId);

Step 2: Upload Files (Binary/Stream)

Upload one or more files using the session ID. Each file is uploaded individually as binary data.

import { UploadFilePayload } from "@tagshelf/alfred";
import * as fs from "fs";

// Upload first file
const file1Payload: UploadFilePayload = {
    file: {
        buffer: fs.readFileSync("./invoice1.pdf"),
        originalName: "invoice1.pdf",
        mimetype: "application/pdf",
    },
    sessionId: session.sessionId,
    metadata: {
        invoiceNumber: "INV-2025-001",
        customerName: "Acme Corp",
    },
};

const file1Response = await client.files.uploadFile(file1Payload);
console.log("File 1 uploaded:", file1Response.fileId);

// Upload second file (same session)
const file2Payload: UploadFilePayload = {
    file: {
        buffer: fs.readFileSync("./invoice2.pdf"),
        originalName: "invoice2.pdf",
        mimetype: "application/pdf",
    },
    sessionId: session.sessionId,
    metadata: {
        invoiceNumber: "INV-2025-002",
        customerName: "Global Inc",
    },
};

const file2Response = await client.files.uploadFile(file2Payload);
console.log("File 2 uploaded:", file2Response.fileId);

Step 3: Create Job to Process Files

Once all files are uploaded, create a job using the session ID. This triggers the processing of all files uploaded to that session.

Important: You cannot create a job if no files have been uploaded to the session.

import { CreateJob, CreateJobResult } from "@tagshelf/alfred";

// Step 3: Create job to process all files in the session
const job: CreateJob = {
    sessionId: session.sessionId,
    metadata: {
        batchId: "BATCH-2025-001",
        processedBy: "automated-workflow",
    },
    channel: "api",
};

const jobResult: CreateJobResult = await client.jobs.create(job);
console.log("Job created:", jobResult.jobId);
// Now Alfred will process all files uploaded to this session

For more information about deferred sessions, see the Deferred Session API documentation.

Upload Files via Remote Sources (URL Upload)

This workflow is ideal when files are already hosted remotely (URLs, AWS S3, GCP, DigitalOcean, etc.). The job is created automatically in the same API call - no session management needed.

Key Difference: Unlike deferred sessions, this method automatically creates a job and Alfred downloads the files using the provided URLs.

import { AlfredClient, Configuration, FileUploadPayload } from "@tagshelf/alfred";

// ... Initialization code here ...

// Upload single file from URL (job created automatically)
const remoteUploadPayload: FileUploadPayload = {
    url: "https://example.com/invoice.pdf",
    metadata: {
        documentType: "invoice",
        source: "external-system",
    },
    parentFilePrefix: "invoices/2025",
};

const response = await client.files.upload(remoteUploadPayload);
console.log("Job created:", response.fileId); // This is actually a job ID
// Alfred will automatically download and process the file

Upload Multiple Files from URLs

// Upload multiple files from URLs (single job for all files)
const multipleFilesPayload: FileUploadPayload = {
    urls: [
        "https://example.com/document1.pdf",
        "https://example.com/document2.pdf",
        "https://example.com/document3.pdf",
    ],
    metadata: [
        { documentId: "DOC-001", type: "invoice" },
        { documentId: "DOC-002", type: "receipt" },
        { documentId: "DOC-003", type: "contract" },
    ],
    propagateMetadata: false, // Each file gets its corresponding metadata
};

await client.files.upload(multipleFilesPayload);

Upload from Cloud Storage (AWS S3, GCP, DigitalOcean)

// Upload from configured cloud storage source
const cloudStoragePayload: FileUploadPayload = {
    source: "my-s3-bucket", // Pre-configured source name in Alfred
    container: "invoices",
    filename: "2025/january/invoice-001.pdf",
    metadata: {
        documentType: "invoice",
        year: "2025",
    },
};

await client.files.upload(cloudStoragePayload);

For more information about remote sources, see the Remote Sources API documentation.

Choosing the Right Upload Method

Feature	Deferred Session (Binary)	Remote Sources (URL)
File Location	Local files, binary data	URLs, cloud storage
Job Creation	Manual (Step 3)	Automatic
Session Required	Yes	No
Use Case	Uploading from local system	Files already hosted remotely
File Download	Not needed (already binary)	Alfred downloads files
API Calls	3 steps (session → upload → job)	1 step (upload creates job)

Create Jobs (Deferred Session Only)

Note: This section applies only to the Deferred Session workflow. When using Remote Sources (URL upload), jobs are created automatically and you don't need to call this method.

A Job represents a single unit of work that groups one or more Files within Alfred. When using deferred sessions, after uploading your files, you must manually create a job to trigger processing.

For more information about jobs, see the Job API documentation.

import { AlfredClient, Configuration, CreateJob, CreateJobResult } from "@tagshelf/alfred";

// ... Initialization code here ...

// Step 1: Create a deferred session
const session = await client.sessions.create();

// Step 2: Upload files to the session
// (See "Upload Files via Deferred Session" examples above)

// Step 3: Create a job to process all files in the session
const job: CreateJob = {
    sessionId: session.sessionId,
    propagateMetadata: true,
    metadata: {
        batchId: "BATCH-2025-001",
        processedBy: "automated-workflow",
    },
    channel: "api",
    parentFilePrefix: "processed/invoices",
};

const jobResult: CreateJobResult = await client.jobs.create(job);
console.log("Job created with ID:", jobResult.jobId);
// Output: Job created with ID: 12345678-1234-1234-1234-123456789abc

Advanced Job Options

// Merge multiple files into a single PDF
const mergeJob: CreateJob = {
    sessionId: session.sessionId,
    merge: true, // Combine all files into a single PDF
    metadata: {
        mergedDocument: "Combined Invoice Package",
        year: "2025",
    },
};

await client.jobs.create(mergeJob);

// Decompose PDF into individual pages
const decomposeJob: CreateJob = {
    sessionId: session.sessionId,
    decompose: true, // Split PDF into individual pages
    pageRotation: 90, // Rotate pages 90 degrees if needed
    metadata: {
        documentType: "contract",
    },
};

await client.jobs.create(decomposeJob);

Get Job Information

Once you've triggered a Job, you can get its information by providing the job ID. This way you can check the stage or status of the job processing so you can access to its results. For more information about the job stages please visit the Job section of our official documentation.

import { AlfredClient, Configuration, JobResult } from "@tagshelf/alfred";

// ... Initialization code here ...

// Get job by ID
const jobId = "12345678-1234-1234-1234-123456789abc";
const jobInfo: JobResult = await client.jobs.get(jobId);

console.log("Job stage:", jobInfo.stage);
console.log("File count:", jobInfo.fileCount);
console.log("Finished files:", jobInfo.finishedFiles);
console.log("Job metadata:", jobInfo.metadata);
console.log("Job files:", jobInfo.files);

Get File Information

You can retrieve detailed information about a file using its ID.

import { AlfredClient, Configuration, File } from "@tagshelf/alfred";

// ... Initialization code here ...

// Get file details by ID
const fileId = "87654321-4321-4321-4321-210987654321";
const fileInfo: File = await client.files.get(fileId);

console.log("File name:", fileInfo.fileName);
console.log("File size:", fileInfo.fileSize);
console.log("Tag name:", fileInfo.tagName);
console.log("Status:", fileInfo.status);
console.log("Classification score:", fileInfo.classificationScore);

Download Files

You can download processed files from Alfred.

import { AlfredClient, Configuration, DownloadResult } from "@tagshelf/alfred";
import * as fs from "fs";

// ... Initialization code here ...

// Download file by ID
const fileId = "87654321-4321-4321-4321-210987654321";
const downloadResult: DownloadResult = await client.files.download(fileId);

// Save to disk
fs.writeFileSync(downloadResult.originalName, downloadResult.buffer);

console.log("Downloaded:", downloadResult.originalName);
console.log("MIME type:", downloadResult.mimetype);
console.log("Size:", downloadResult.buffer.length, "bytes");

Retrieve Data Points

Data Points are the core of Alfred's platform and represent data that you want to extract. Once your job is processed, you can retrieve the data points from the files if the job was successful. For more information visit the Metadata section of our official documentation.

Important

Data Points were previously known as Metadata.

import { AlfredClient, Configuration, DataPointResult } from "@tagshelf/alfred";

// ... Initialization code here ...

// Get Data Points by File ID
const fileId = "87654321-4321-4321-4321-210987654321";
const dataPoints: DataPointResult[] = await client.dataPoints.getValues(fileId);

// Process extracted data points
dataPoints.forEach((dataPoint) => {
    console.log(`${dataPoint.metadataName}: ${dataPoint.value}`);
    console.log(`Confidence: ${dataPoint.classificationScore}`);
});

Real-Time Events

The alfred-node library provides a way to listen to events emitted by Alfred IPA in real-time through a websockets implementation. This feature is particularly useful when you need to monitor the progress of a Job, File, or any other event that occurs within the Alfred platform. To see more information visit our official documentation.

Getting started

To get started, you need to create an instance of the AlfredRealTimeClient class.

import { Configuration, AlfredRealTimeClient } from "@tagshelf/alfred";

const config: Configuration = Configuration.default("production");
const realTimeClient: AlfredRealTimeClient = new AlfredRealTimeClient(
    config,
    "your-api-key"
);

File Events

These events are specifically designed to respond to a variety of actions or status changes related to Files. The library provides fully typed file events for type safety. To see more details about File events, visit our official documentation.

import { FileEvent, AlfredEvent } from "@tagshelf/alfred";

// Listen to all file events with full typing
realTimeClient.onFileEvent((event: FileEvent) => {
    console.log("File event received:", event.eventName);
    console.log("Company ID:", event.companyId);
    
    // Type-safe event handling based on event name
    switch (event.eventName) {
        case AlfredEvent.FileDone:
            console.log("File processing completed!");
            console.log("File ID:", event.fileId);
            console.log("Tag Name:", event.tagName);
            console.log("File Status:", event.fileStatus);
            break;
            
        case AlfredEvent.FileStatusUpdate:
            console.log("File status updated");
            console.log("File ID:", event.fileId);
            console.log("Classification Score:", event.classificationScore);
            console.log("New Status:", event.fileStatus);
            break;
            
        case AlfredEvent.FileFailed:
            console.log("File processing failed");
            console.log("File ID:", event.fileId);
            console.log("Tag Name:", event.tagName);
            break;
            
        case AlfredEvent.FileMove:
            console.log("File moved");
            console.log("File ID:", event.fileId);
            console.log("From:", event.previousFileDirectory);
            console.log("To:", event.newFileDirectory);
            break;
    }
});

Job Events

Alfred performs asynchronous document classification, extraction, and indexing on a variety of file types. The events detailed here offer insights into how a Job progresses, fails, retries, or completes its tasks. To see more details about Job events, visit our official documentation.

import { JobEvent, AlfredEvent } from "@tagshelf/alfred";

// Listen to all job events with full typing
realTimeClient.onJobEvent((event: JobEvent) => {
    console.log("Job event received:", event.eventName);
    console.log("Job ID:", event.jobId);
    
    // Type-safe event handling based on event name
    switch (event.eventName) {
        case AlfredEvent.JobCreate:
            console.log("Job created!");
            console.log("File Count:", event.fileCount);
            console.log("User:", event.userName);
            console.log("Metadata:", event.metadata);
            break;
            
        case AlfredEvent.JobStart:
            console.log("Job processing started");
            console.log("Job ID:", event.jobId);
            break;
            
        case AlfredEvent.JobStageUpdate:
            console.log("Job stage updated");
            console.log("Job ID:", event.jobId);
            console.log("New Stage:", event.stage);
            break;
            
        case AlfredEvent.JobFinished:
            console.log("Job completed successfully!");
            console.log("Job ID:", event.jobId);
            break;
            
        case AlfredEvent.JobFailed:
            console.log("Job failed");
            console.log("Job ID:", event.jobId);
            console.log("Retries:", event.retries);
            console.log("Exceeded Retries:", event.exceededRetries);
            break;
            
        case AlfredEvent.JobRetry:
            console.log("Job retrying");
            console.log("Job ID:", event.jobId);
            console.log("Retry Count:", event.retries);
            break;
            
        case AlfredEvent.JobInvalid:
            console.log("Job is invalid");
            console.log("Job ID:", event.jobId);
            console.log("Retries:", event.retries);
            console.log("Exceeded Retries:", event.exceededRetries);
            console.log("Has Broken Input Sources:", event.hasBrokenInputSources);
            break;
            
        case AlfredEvent.JobExceededRetries:
            console.log("Job exceeded retry limit");
            console.log("Job ID:", event.jobId);
            console.log("Retries:", event.retries);
            break;
    }
});

Specific Event Listening

You can also listen to specific events using the on() method. This is useful when you want to monitor a particular event type or when new events are introduced that have not yet received dedicated methods in the library.

import { AlfredEvent } from "@tagshelf/alfred";

// Listen to a specific job event
realTimeClient.on<JobEvent>(AlfredEvent.JobFinished, (event) => {
    console.log("Job finished:", event.jobId);
});

// Listen to a specific file event
realTimeClient.on<FileEvent>(AlfredEvent.FileDone, (event) => {
    console.log("File done:", event.fileId);
    console.log("Tag applied:", event.tagName);
});

// Listen to file extraction data events
realTimeClient.on(AlfredEvent.FileExtractedDataCreate, (event: any) => {
    console.log("Data extracted from file:", event.fileLogId);
    console.log("Extracted content:", event.content);
    console.log("Provider:", event.provider);
});

Available Event Types

The library supports the following event types through the AlfredEvent enum:

Job Events:

AlfredEvent.JobCreate - Job is created
AlfredEvent.JobStart - Job processing starts
AlfredEvent.JobStageUpdate - Job stage changes
AlfredEvent.JobFinished - Job completes successfully
AlfredEvent.JobFailed - Job fails
AlfredEvent.JobRetry - Job is retrying
AlfredEvent.JobExceededRetries - Job exceeded retry limit
AlfredEvent.JobInvalid - Job is invalid

File Events:

AlfredEvent.FileStatusUpdate - File status changes
AlfredEvent.FileDone - File processing complete
AlfredEvent.FileFailed - File processing failed
AlfredEvent.FileMove - File moved to different location
AlfredEvent.FileUpdate - File updated
AlfredEvent.FileChangeTag - File tag changed
AlfredEvent.FileRemoveTag - Tag removed from file
AlfredEvent.FileAddToJob - File added to job
AlfredEvent.FileMoveToPending - File moved to pending
AlfredEvent.FileMoveToRecycleBin - File moved to recycle bin
AlfredEvent.FilePropertyCreate - File property created
AlfredEvent.FilePropertyDelete - File property deleted
AlfredEvent.FileExtractedDataCreate - Data extracted from file
AlfredEvent.FileExtractedDataDelete - Extracted data deleted
AlfredEvent.FileCategoryCreate - File category created
AlfredEvent.FileCategoryDelete - File category deleted

Disconnect

When you're done listening to events, disconnect the real-time client to close the websocket connection.

realTimeClient.disconnect();

Reference

This is the class reference for the alfred-node library.

`AlfredClient`

The AlfredClient class is the main class that provides access to all the Alfred API endpoints.

Constructor

new AlfredClient(config: Configuration, auth: Auth);

Client Configuration

The Configuration class provides the configuration for the AlfredClient.

Configuration.default(environment: "production"): Configuration;

Authentication

The Auth type provides the authentication methods for the AlfredClient.

type Auth = 
  | { apiKey: string }
  | { 
      hmac: {
        key: string;
        secret: string;
      }
    }
  | { 
      oauth: {
        username: string;
        password: string;
      }
    };

Domains

The AlfredClient class provides access to the following domains:

sessions:
files:
jobs:
datapoints:
accounts:

Each domain provides access to a set of methods that interact with the Alfred API.

Session Domain Methods

- `create()` Method

Signature

create(): Promise<CreateSessionResult>;

Description

Creates a new deferred session in Alfred.

Returns

A Promise that resolves to an object of type CreateSessionResult with the following properties:

Key	Type	Description
`sessionId`	string	Session ID

- `get()` Method

Signature

get(id: string): Promise<GetSessionResult>;

Description

Retrieves a deferred session by its ID.

Parameters

id: The ID of the session to retrieve.

Returns

A Promise that resolves to an object of type GetSessionResult with the following properties:

Key	Type	Description
`id`	string	Session ID
`creationDate`	string	Session creation date
`updateDate`	string	Session update date
`status`	string	Session status
`userName`	string	User name
`companyId`	string	Company ID
`jobId`	string \| null	Associated job ID if any

File Domain Methods

`uploadFile()` Method

Signature

uploadFile(payload: UploadFilePayload): Promise<{ fileId: string }>;

Description

Uploads a local file to Alfred.

Parameters- payload: An object of type UploadFilePayload with the following properties:

Key	Type	Description
`file`	File	Object containing the file buffer, original name, and mimetype.
`sessionId`	string	Session ID to link multiple files to a job.
`metadata`	any	JSON object or JSON array of objects containing metadata fields for a given remote file.

Returns

A Promise that resolves to an object of type UploadFileResponse with the following properties:
Key Type Description

id string File ID

name string File name

mimetype string File mimetype

size number File size

metadata any File metadata

`upload()` Method

Signature

upload(payload: FileUploadPayload): Promise<{ fileId: string }>;

Description

Uploads a file from a remote source to Alfred.

Parameters- payload: An object of type FileUploadPayload with the following properties:

Key	Type	Description
`url`	string	URL of the file to upload (use url, when you have an URl to single remote file.)
`urls`	string[]	URLs of the files to upload. (Use urls, when you have URl's for multiple remote files. The current limit for this parameter is 100 elements.)
`source`	string	Configured object storage source name. Ideal for referring to files hosted in existing cloud containers. When used, file_name and container are required.
`container`	string	Virtual container where the referenced remote file is located. When used, source and file_name are required.
`filename`	string	Unique name of the file within an object storage source. When used, source and container are required.
`filenames`	string[]	Array of unique names of the files within an object storage source. When used, source and container are required.
`merge`	boolean	Boolean value [true/false] - When set to true, will merge all of the remote files into a single PDF file. All of the remote files MUST be images. By default this field is set to false.
`metadata`	any	JSON object or JSON array of objects containing metadata fields for a given remote file. When merge field is set to false: When using the urls field this should be a JSON object array that matches the urls field array length. When using the url field the metadata field should be a JSON object. When the merge field is set to true: The metadata field should be a JSON object.
`propagateMetadata`	boolean	This parameter enables the specification of a single metadata object to be applied across multiple files from remote URLs or remote sources. When used, `propagate_metadata` ensures that the defined metadata is consistently attached to all the specified files during their upload and processing. This feature is particularly useful for maintaining uniform metadata across a batch of files, streamlining data organization and retrieval.
`parentFilePrefix`	string	The `parent_file_prefix` parameter is used to specify a virtual folder destination for the uploaded files, diverging from the default 'Inbox' folder. By setting this parameter, users can organize files into specific virtual directories, enhancing file management and accessibility within Alfred's system.

Returns

A Promise that resolves to an object of type UploadResponse with the following properties:
Key Type Description

id string File ID

name string File name

mimetype string File mimetype

size number File size

metadata any File metadata

`get()` Method

Signature

get(id: string): Promise<File>;

Description

Retrieves detailed information about a file by its ID.

Parameters

id: The ID of the file to retrieve.

Returns

A Promise that resolves to an object of type File with the file details including:

Key	Type	Description
`id`	string	File ID
`fileName`	string	File name
`fileSize`	number	File size in bytes
`tagName`	string	Applied tag name
`tagId`	string	Applied tag ID
`status`	string	File processing status
`classificationScore`	number	Classification confidence score
`blobUrl`	string	File blob URL
`contentType`	string	File MIME type
`metadata`	string \| null	File metadata
...and more		See `File` interface for complete details

`download()` Method

Signature

download(id: string): Promise<DownloadResult>;

Description

Downloads a file from Alfred by its ID.

Parameters

id: The ID of the file to download.

Returns

A Promise that resolves to an object of type DownloadResult with the following properties:

Key	Type	Description
`buffer`	Buffer	File content as a Buffer
`originalName`	string	Original file name
`mimetype`	string	File MIME type

Job Domain Methods

`create()` Method

Signature

create(job: CreateJob): Promise<CreateJobResult>;

Description

Creates a new job in Alfred.

Parameters

job: An object of type CreateJob with the following properties:

Key	Type	Description
`sessionId`	string	Session ID
`metadata`	any	Metadata of the job
`propagateMetadata`	boolean	If `true` ensures that the provided metadata at the Job level is attached to all the specified Files.
`merge`	boolean	If `true`, when all provided Files are either images or PDFs, the system combines them into a single file for the purpose of processing.
`decompose`	boolean	If `true`, when the provided File is a PDF, the system will decompose it into individual pages for processing.
`channel`	string	Channel
`parentFilePrefix`	string	The `parent_file_prefix` parameter is used to specify a virtual folder destination for the uploaded files, diverging from the default 'Inbox' folder. By setting this parameter, users can organize files into specific virtual directories, enhancing file management and accessibility within Alfred's system.
`pageRotation`	number	Page rotation
`container`	string	Virtual container where the referenced remote file is located.
`filename`	string	Unique name of the file within an object storage source.
`filenames`	string[]	Array of unique names of the files within an object storage source.

Returns

A Promise that resolves to an object of type CreateJobResult with the following properties:

Key	Type	Description
`jobId`	string	ID of the created Job.

`get()` Method

Signature

get(id: string): Promise<JobResult>;

Description

Retrieves a job by its ID.

Parameters

id: The ID of the job to retrieve.

Returns

A Promise that resolves to an object of type JobResult with the following properties:

Key	Type	Description
`id`	string	Job ID
`creationDate`	string	Job creation date
`hasJobRequestInfo`	boolean	Indicates if the job has request information
`jobRequestDate`	string (optional)	Job request date
`updateDate`	string	Job update date
`companyId`	string	Company ID
`bulkId`	string (optional)	Bulk ID
`deferredSessionId`	string	Deferred session ID
`userName`	string	User name
`channel`	string	Channel
`source`	string (optional)	Source
`container`	string (optional)	Container
`remoteFileName`	string (optional)	Remote file name
`remoteFileNames`	string (optional)	Remote file names
`merge`	boolean	Merge flag
`decompose`	boolean	Decompose flag
`propagateMetadata`	boolean	Propagate metadata flag
`parentFilePrefix`	string (optional)	Parent file prefix
`decomposedPageRotation`	number	Decomposed page rotation
`fileCount`	number	File count
`fileSourcesCount`	number	File sources count
`metadataObjectsCount`	number	Metadata objects count
`finishedFiles`	number	Finished files count
`files`	object array	Array of file objects, each containing `id`, `creationDate`, `updateDate`, `fileName`, `tagName`, `isParent`, `isChildren`, `status`
`retries`	number	Number of retries
`exceededRetries`	boolean	Flag indicating if retries were exceeded
`fileUrls`	string array	Array of file URLs
`errorMessages`	string array	Array of error messages
`stage`	string	Job stage
`startDate`	string	Job start date
`emailFrom`	string (optional)	Email from
`emailSubject`	string (optional)	Email subject
`emailBody`	string (optional)	Email body

Data Points Domain Methods

`getValues()` Method

Signature

getValues(fileId: string): Promise<DataPointResult[]>;

Description

Retrieves the data points of a file by its ID.

Parameters

fileId: string: The ID of the file to retrieve data points from.

Returns

A Promise that resolves to an object of type DataPointResult[] with the following properties:
Key Type Description
|id | string | Data point ID | | fileLogId | string | File log ID | | metadataId | string | Metadata ID |
| metadataName | string | Metadata name | | classificationScore | number | Classification score |

Account Domain Methods

`whoAmI()` Method

Signature

whoAmI(): Promise<any>;

Description

Retrieves the account information of the authenticated user.

Returns

A Promise that resolves to an object of type any with the information of the authenticated user.

Contributing

Contributions to improve this library are welcome. Please feel free to fork the repository, make your changes, and submit a pull request for review.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Folders and files

Latest commit

History

Repository files navigation

Table of Contents

Overview

Alfred

Features

Prerequisites

Installation

Usage

Initialize the Client

Environments description

Authentication Methods

Upload Files

Upload Files via Deferred Session (Binary Upload)

Upload Files via Remote Sources (URL Upload)

Choosing the Right Upload Method

Create Jobs (Deferred Session Only)

Get Job Information

Get File Information

Download Files

Retrieve Data Points

Real-Time Events

Getting started

File Events

Job Events

Specific Event Listening

Available Event Types

Disconnect

Reference

AlfredClient

Constructor

Client Configuration

Authentication

Domains

Session Domain Methods

- create() Method

- get() Method

File Domain Methods

uploadFile() Method

upload() Method

get() Method

download() Method

Job Domain Methods

create() Method

get() Method

Data Points Domain Methods

getValues() Method

Account Domain Methods

whoAmI() Method

Contributing

License

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases 10

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

`AlfredClient`

- `create()` Method

- `get()` Method

`uploadFile()` Method

`upload()` Method

`get()` Method

`download()` Method

`create()` Method

`get()` Method

`getValues()` Method

`whoAmI()` Method

Packages