@bluecopa/core 0.1.94 → 0.1.96

package/dist/api/databox/dropFileToDatabox.d.ts

@@ -0,0 +1,22 @@
+import { DataboxFile } from './types';
+export interface DropFileToDataboxRequest {
+    folderId: string;
+    file: File;
+    /** CSV delimiter override (CSV files only) */
+    delimiter?: string;
+}
+/**
+ * Drops (uploads) a file into a databox folder. The file is uploaded to blob
+ * storage and registered with processing scheduled. Poll
+ * getDataboxFileStatus with the returned file id for the run result.
+ *
+ * Supported types: csv, xlsx, xls, xlsb, json.
+ *
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @param params.file - Required: The file to upload
+ * @param params.delimiter - Optional: CSV delimiter override
+ * @returns Promise<DataboxFile> The created databox file (with id and status)
+ * @throws Error if the request fails
+ */
+export declare function dropFileToDatabox({ folderId, file, delimiter, }: DropFileToDataboxRequest): Promise<DataboxFile>;

package/dist/api/databox/getDataboxFile.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFile } from './types';
+export interface GetDataboxFileRequest {
+    fileId: string;
+}
+/**
+ * Gets a databox file's details, including its processing status
+ * @param params - The request parameters
+ * @param params.fileId - Required: The databox file ID
+ * @returns Promise<DataboxFile> The file details
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFile({ fileId, }: GetDataboxFileRequest): Promise<DataboxFile>;

package/dist/api/databox/getDataboxFileDownloadUrl.d.ts

@@ -0,0 +1,13 @@
+import { DataboxFileDownloadUrl } from './types';
+export interface GetDataboxFileDownloadUrlRequest {
+    fileId: string;
+}
+/**
+ * Gets a presigned download URL for a databox file's stored content. The
+ * caller downloads the content directly from the returned URL.
+ * @param params - The request parameters
+ * @param params.fileId - Required: The databox file ID
+ * @returns Promise<DataboxFileDownloadUrl> The presigned URL and file details
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFileDownloadUrl({ fileId, }: GetDataboxFileDownloadUrlRequest): Promise<DataboxFileDownloadUrl>;

package/dist/api/databox/getDataboxFileRuns.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFileProcessingResult } from './types';
+export interface GetDataboxFileRunsRequest {
+    fileId: string;
+}
+/**
+ * Gets the full processing (run) result history of a databox file
+ * @param params - The request parameters
+ * @param params.fileId - Required: The databox file ID
+ * @returns Promise<DataboxFileProcessingResult[]> The run results
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFileRuns({ fileId, }: GetDataboxFileRunsRequest): Promise<DataboxFileProcessingResult[]>;

package/dist/api/databox/getDataboxFileStatus.d.ts

@@ -0,0 +1,13 @@
+import { DataboxFileProcessingResult } from './types';
+export interface GetDataboxFileStatusRequest {
+    fileId: string;
+}
+/**
+ * Gets the latest processing (run) result of a databox file — poll this after
+ * dropping a file or triggering a folder run to get the run status.
+ * @param params - The request parameters
+ * @param params.fileId - Required: The databox file ID
+ * @returns Promise<DataboxFileProcessingResult> The latest run result
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFileStatus({ fileId, }: GetDataboxFileStatusRequest): Promise<DataboxFileProcessingResult>;

package/dist/api/databox/getDataboxFolder.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFolder } from './types';
+export interface GetDataboxFolderRequest {
+    folderId: string;
+}
+/**
+ * Gets a databox folder's details
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxFolder> The folder details
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFolder({ folderId, }: GetDataboxFolderRequest): Promise<DataboxFolder>;

package/dist/api/databox/getDataboxFolderDatasets.d.ts

@@ -0,0 +1,14 @@
+import { DataboxDataset } from './types';
+export interface GetDataboxFolderDatasetsRequest {
+    folderId: string;
+}
+/**
+ * Lists the datasets produced by a databox folder's processing. Use the
+ * returned dataset id with getDatasetExceptions to fetch the dataset's
+ * exception rows.
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxDataset[]> The folder's datasets
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFolderDatasets({ folderId, }: GetDataboxFolderDatasetsRequest): Promise<DataboxDataset[]>;

package/dist/api/databox/getDataboxFolderDuplicates.d.ts

@@ -0,0 +1,15 @@
+import { DataboxDatasetDuplicates } from './types';
+export interface GetDataboxFolderDuplicatesRequest {
+    folderId: string;
+}
+/**
+ * Gets the duplicate record combinations for every dataset produced by a
+ * databox folder — no dataset id required, datasets and their configured
+ * duplicate column groups are resolved automatically. One entry per
+ * dataset x group (entries that fail to load carry an `error` message).
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxDatasetDuplicates[]> Duplicates per dataset and group
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFolderDuplicates({ folderId, }: GetDataboxFolderDuplicatesRequest): Promise<DataboxDatasetDuplicates[]>;

package/dist/api/databox/getDataboxFolderFiles.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFile } from './types';
+export interface GetDataboxFolderFilesRequest {
+    folderId: string;
+}
+/**
+ * Lists the files of a databox folder, each with its processing status
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxFile[]> The folder's files
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFolderFiles({ folderId, }: GetDataboxFolderFilesRequest): Promise<DataboxFile[]>;

package/dist/api/databox/getDataboxFolderSchema.d.ts

@@ -0,0 +1,14 @@
+import { DataboxFolderSchema } from './types';
+export interface GetDataboxFolderSchemaRequest {
+    folderId: string;
+}
+/**
+ * Gets the databox folder's schema available for update: the existing sync
+ * catalog plus, for non-auto-process folders, the schema inferred from the
+ * first file (the "Update Schema" action source data).
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxFolderSchema> The folder schema
+ * @throws Error if the request fails
+ */
+export declare function getDataboxFolderSchema({ folderId, }: GetDataboxFolderSchemaRequest): Promise<DataboxFolderSchema>;

package/dist/api/databox/getDataboxSchemaHistory.d.ts

@@ -0,0 +1,13 @@
+import { DataboxSchemaUpdateResult } from './types';
+export interface GetDataboxSchemaHistoryRequest {
+    folderId: string;
+}
+/**
+ * Gets the schema update history of a databox folder (the "Schema update
+ * history" tab).
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxSchemaUpdateResult[]> The schema update results
+ * @throws Error if the request fails
+ */
+export declare function getDataboxSchemaHistory({ folderId, }: GetDataboxSchemaHistoryRequest): Promise<DataboxSchemaUpdateResult[]>;

package/dist/api/databox/getDataboxTrashFiles.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFile } from './types';
+export interface GetDataboxTrashFilesRequest {
+    folderId: string;
+}
+/**
+ * Lists the trashed files of a databox folder (the "Trash" view)
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @returns Promise<DataboxFile[]> The trashed files
+ * @throws Error if the request fails
+ */
+export declare function getDataboxTrashFiles({ folderId, }: GetDataboxTrashFilesRequest): Promise<DataboxFile[]>;

package/dist/api/databox/index.d.ts

@@ -0,0 +1,18 @@
+export * from './types';
+export * from './getDataboxFolder';
+export * from './getDataboxFolderFiles';
+export * from './getDataboxFolderDatasets';
+export * from './getDataboxFolderDuplicates';
+export * from './dropFileToDatabox';
+export * from './runDataboxFolder';
+export * from './getDataboxFolderSchema';
+export * from './updateDataboxFolderSchema';
+export * from './getDataboxSchemaHistory';
+export * from './getDataboxTrashFiles';
+export * from './getDataboxFile';
+export * from './getDataboxFileStatus';
+export * from './getDataboxFileRuns';
+export * from './getDataboxFileDownloadUrl';
+export * from './trashDataboxFiles';
+export * from './restoreDataboxFile';
+export * from './permanentDeleteDataboxFiles';

package/dist/api/databox/permanentDeleteDataboxFiles.d.ts

@@ -0,0 +1,11 @@
+export interface PermanentDeleteDataboxFilesRequest {
+    fileIds: string[];
+}
+/**
+ * Permanently deletes databox files. This action is irreversible.
+ * @param params - The request parameters
+ * @param params.fileIds - Required: The databox file IDs to delete
+ * @returns Promise<any> Per-file deletion status
+ * @throws Error if the request fails
+ */
+export declare function permanentDeleteDataboxFiles({ fileIds, }: PermanentDeleteDataboxFilesRequest): Promise<any>;

package/dist/api/databox/restoreDataboxFile.d.ts

@@ -0,0 +1,12 @@
+import { DataboxFile } from './types';
+export interface RestoreDataboxFileRequest {
+    fileId: string;
+}
+/**
+ * Restores a trashed databox file back to its folder
+ * @param params - The request parameters
+ * @param params.fileId - Required: The databox file ID
+ * @returns Promise<DataboxFile> The restored file
+ * @throws Error if the request fails
+ */
+export declare function restoreDataboxFile({ fileId, }: RestoreDataboxFileRequest): Promise<DataboxFile>;

package/dist/api/databox/runDataboxFolder.d.ts

@@ -0,0 +1,16 @@
+export interface RunDataboxFolderRequest {
+    folderId: string;
+    /** Force reprocessing of already-processed files */
+    force?: boolean;
+}
+/**
+ * Triggers processing of a databox folder's contents (the "Run" action).
+ * Processing is asynchronous — poll getDataboxFileStatus / getDataboxFolderFiles
+ * for run results.
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @param params.force - Optional: Force reprocessing
+ * @returns Promise<void>
+ * @throws Error if the request fails
+ */
+export declare function runDataboxFolder({ folderId, force, }: RunDataboxFolderRequest): Promise<void>;

package/dist/api/databox/trashDataboxFiles.d.ts

@@ -0,0 +1,12 @@
+export interface TrashDataboxFilesRequest {
+    fileIds: string[];
+}
+/**
+ * Moves databox files to trash (scheduled delete). Trashed files can be
+ * restored via restoreDataboxFile.
+ * @param params - The request parameters
+ * @param params.fileIds - Required: The databox file IDs to trash
+ * @returns Promise<any> Per-file deletion status
+ * @throws Error if the request fails
+ */
+export declare function trashDataboxFiles({ fileIds, }: TrashDataboxFilesRequest): Promise<any>;

package/dist/api/databox/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared types for the databox (drive folder) API functions.
+ * Mirrors the BFF responses of /api/v1/databox/*.
+ */
+export type DataboxFileStatus = "PENDING" | "PROCESSING_SCHEDULED" | "PROCESSING" | "PROCESSING_FAILED" | "SCHEMA_VALIDATION_FAILED" | "DATA_VALIDATION_FAILED" | "DATA_VALIDATION_SUCCEEDED" | "DATA_SYNC_FAILED" | "SUCCEEDED" | "DELETE_SCHEDULED" | "DELETING_DATA" | "DELETED_DATA" | "DELETE_FAILED" | string;
+export interface DataboxFile {
+    id?: string;
+    name?: string;
+    type?: "CSV" | "XLSX" | "JSON" | "XLS" | "XLSB" | string;
+    parentId?: string;
+    status?: DataboxFileStatus;
+    blobFileId?: string;
+    copaUploadDate?: string;
+    [key: string]: any;
+}
+export interface DataboxFolder {
+    id?: string;
+    name?: string;
+    status?: string;
+    autoProcessFiles?: boolean;
+    [key: string]: any;
+}
+export interface DataboxFileProcessingResult {
+    id?: string;
+    driveFileId?: string;
+    status?: string;
+    errorMessages?: string[];
+    [key: string]: any;
+}
+export interface DataboxSchemaUpdateResult {
+    id?: string;
+    folderId?: string;
+    status?: string;
+    [key: string]: any;
+}
+export interface DataboxFolderSchema {
+    existingSchema?: {
+        streams?: any[];
+    };
+    folderOriginalSchema?: Record<string, Record<string, string>>;
+    [key: string]: any;
+}
+export interface DataboxFileDownloadUrl {
+    url: string;
+    file: DataboxFile;
+}
+/** Duplicate combinations of one duplicate column group of one dataset produced by a databox folder. */
+export interface DataboxDatasetDuplicates {
+    datasetId?: string;
+    datasetName?: string;
+    group?: string;
+    columns?: string[];
+    schema?: {
+        name: string;
+        data_type: string;
+    }[];
+    /** Duplicated value combinations with their row_count */
+    data?: any[];
+    /** Present when this group's duplicates failed to load. */
+    error?: string;
+}
+/** Dataset produced by a databox folder's processing (id: `<folderId>_<streamName>`). */
+export interface DataboxDataset {
+    id?: string;
+    name?: string;
+    displayName?: string;
+    runStatus?: "RUNNING" | "SUCCESS" | "FAILED" | "SCHEDULED" | "SCHEDULE_FAILED" | string;
+    importType?: string;
+    lastSyncedTime?: string;
+    published?: boolean;
+    [key: string]: any;
+}
+/** File extensions accepted by databox uploads. */
+export declare const DATABOX_SUPPORTED_EXTENSIONS: readonly ["csv", "xlsx", "xls", "xlsb", "json"];

package/dist/api/databox/updateDataboxFolderSchema.d.ts

@@ -0,0 +1,16 @@
+import { DataboxFolder } from './types';
+export interface UpdateDataboxFolderSchemaRequest {
+    folderId: string;
+    /** Configured airbyte streams for the folder's sync catalog */
+    streams: any[];
+}
+/**
+ * Submits an updated sync catalog for the databox folder (the "Update Schema"
+ * action).
+ * @param params - The request parameters
+ * @param params.folderId - Required: The databox folder ID
+ * @param params.streams - Required: The configured streams
+ * @returns Promise<DataboxFolder> The updated folder
+ * @throws Error if the request fails
+ */
+export declare function updateDataboxFolderSchema({ folderId, streams, }: UpdateDataboxFolderSchemaRequest): Promise<DataboxFolder>;

package/dist/api/dataset/getDatasetDuplicates.d.ts

@@ -0,0 +1,28 @@
+export interface GetDatasetDuplicatesRequest {
+    datasetId: string;
+    /** Optional: scope to a single configured duplicate column group by name */
+    group?: string;
+}
+export interface DatasetDuplicates {
+    group?: string;
+    columns?: string[];
+    schema?: {
+        name: string;
+        data_type: string;
+    }[];
+    /** Duplicated value combinations with their row_count */
+    data?: any[];
+    /** Present when this group's duplicates failed to load. */
+    error?: string;
+}
+/**
+ * Gets the duplicate record combinations for each duplicate column group
+ * configured on the dataset (the catalog "Duplicates" tab). Returns [] when
+ * the dataset has no duplicate column groups configured.
+ * @param params - The request parameters
+ * @param params.datasetId - Required: The dataset ID
+ * @param params.group - Optional: a single group name to scope to
+ * @returns Promise<DatasetDuplicates[]> Duplicates per column group
+ * @throws Error if the request fails
+ */
+export declare function getDatasetDuplicates({ datasetId, group, }: GetDatasetDuplicatesRequest): Promise<DatasetDuplicates[]>;

package/dist/api/dataset/getDatasetExceptions.d.ts

@@ -0,0 +1,20 @@
+export interface GetDatasetExceptionsRequest {
+    datasetId: string;
+}
+export interface DatasetExceptions {
+    schema?: {
+        name: string;
+        data_type: string;
+    }[];
+    data?: any[];
+    [key: string]: any;
+}
+/**
+ * Gets the dataset rows matching the dataset's exception rules (the catalog
+ * "Exceptions" tab). Returns the same bounded sample shown in the UI grid.
+ * @param params - The request parameters
+ * @param params.datasetId - Required: The dataset ID (databox datasets are keyed `<folderId>_<streamName>`)
+ * @returns Promise<DatasetExceptions> The exception rows and schema
+ * @throws Error if the request fails
+ */
+export declare function getDatasetExceptions({ datasetId, }: GetDatasetExceptionsRequest): Promise<DatasetExceptions>;

package/dist/api/dataset/getVirtualDatasets.d.ts

@@ -0,0 +1,2 @@
+import { VirtualDataset } from '../../../../models/src/lib/gen/Api';
+export declare const getVirtualDatasets: () => Promise<VirtualDataset[]>;

package/dist/api/dataset/index.d.ts

@@ -1,3 +1,6 @@
 export * from './getData';
 export * from './getSampleData';
 export * from './getDatasets';
+export * from './getVirtualDatasets';
+export * from './getDatasetExceptions';
+export * from './getDatasetDuplicates';

package/dist/api/definition/runPublishedDefinition.d.ts

@@ -16,5 +16,10 @@ export declare const runPublishedDefinition: (props: {
      * original `published/run` pass-through.
      */
     solutionBindings?: Record<string, unknown>;
+    /**
+     * Optional row limit. When omitted, the BFF falls back to the server's
+     * ROW_LIMIT default.
+     */
+    limit?: number;
     source?: CancelTokenSource;
 }) => Promise<import('axios').AxiosResponse<any, any, {}>>;

package/dist/api/index.d.ts

@@ -23,3 +23,4 @@ export * as clientIp from './clientIp';
 export * as emailEngine from './emailEngine';
 export * as tcn from './tcn';
 export * as templates from './templates';
+export * as databox from './databox';

package/dist/api/metric/getData.d.ts

@@ -10,6 +10,11 @@ export declare const getData: (metricSheetId: string, options?: {
      * round-trip. Omit/undefined → getData fetches on its own.
      */
     solutionBindings?: Record<string, unknown>;
+    /**
+     * Optional row limit forwarded to the published-definition runs. When
+     * omitted, the BFF falls back to the server's ROW_LIMIT default.
+     */
+    limit?: number;
 }) => Promise<{
     data?: undefined;
 } | {

package/dist/api/reconV2/createReconV2.d.ts

@@ -1,22 +1,35 @@
 export interface ReconV2Workflow {
     [key: string]: any;
 }
+export interface ReconV2DatasetRef {
+    id: string;
+    name: string;
+    dateColumn?: string | null;
+}
 export interface CreateReconV2Request {
     /** Workflow name — non-alphanumeric characters are replaced with underscores */
     name: string;
     /** Recon type, defaults to SMART_RECONCILIATION */
     type?: string;
+    /** Left (primary/source) dataset — provide together with rightDataset to make the workflow immediately runnable */
+    leftDataset?: ReconV2DatasetRef;
+    /** Right (secondary/target) dataset — provide together with leftDataset */
+    rightDataset?: ReconV2DatasetRef;
     /** Optional initial workflow config (leftDef, rightDef, matchGroups, sources, ...) */
     config?: Partial<ReconV2Workflow>;
 }
 /**
  * Creates a recon v2 (SMART_RECONCILIATION) workflow along with its backing
- * RECON workbook
+ * RECON workbook. When leftDataset + rightDataset are provided, the workbook
+ * sheets and workflow defs are wired to the datasets so the workflow can be
+ * run immediately (smart mode auto-detects match columns).
  * @param params - The create parameters
  * @param params.name - Required: Name for the new reconciliation
  * @param params.type - Optional: Recon type (defaults to SMART_RECONCILIATION)
+ * @param params.leftDataset - Optional: Left dataset { id, name, dateColumn? }
+ * @param params.rightDataset - Optional: Right dataset { id, name, dateColumn? }
  * @param params.config - Optional: Initial workflow config to merge in
  * @returns Promise<ReconV2Workflow> The created workflow
  * @throws Error if the request fails
  */
-export declare function createReconV2({ name, type, config, }: CreateReconV2Request): Promise<ReconV2Workflow>;
+export declare function createReconV2({ name, type, leftDataset, rightDataset, config, }: CreateReconV2Request): Promise<ReconV2Workflow>;

package/dist/api/reconV2/getReconV2Runs.d.ts

@@ -0,0 +1,20 @@
+export interface GetReconV2RunsRequest {
+    workflowId: string;
+}
+export interface ReconV2Run {
+    id?: string;
+    workflowId?: string;
+    status?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    errorMessages?: string[];
+    [key: string]: any;
+}
+/**
+ * Gets the run history of a recon v2 workflow
+ * @param params - The request parameters
+ * @param params.workflowId - Required: The workflow ID
+ * @returns Promise<ReconV2Run[]> The runs (newest first)
+ * @throws Error if the request fails
+ */
+export declare function getReconV2Runs({ workflowId, }: GetReconV2RunsRequest): Promise<ReconV2Run[]>;

package/dist/api/reconV2/index.d.ts

@@ -3,6 +3,7 @@ export * from './updateReconV2';
 export * from './deleteReconV2';
 export * from './runReconV2';
 export * from './getAllReconV2Workflows';
+export * from './getReconV2Runs';
 export * from './getReconV2RunResult';
 export * from './getReconV2SmartResult';
 export * from './profileReconV2';

package/dist/api/reconV2/updateReconV2.d.ts

@@ -1,15 +1,26 @@
-import { ReconV2Workflow } from './createReconV2';
+import { ReconV2DatasetRef, ReconV2Workflow } from './createReconV2';
 export interface UpdateReconV2Request {
     /** Full workflow object including its id */
     reconWorkflow: ReconV2Workflow;
+    /** Optional: rewire the primary (left) sheet to this dataset */
+    leftDataset?: ReconV2DatasetRef;
+    /** Optional: rewire the secondary (right) sheet to this dataset */
+    rightDataset?: ReconV2DatasetRef;
 }
 /**
  * Updates (saves) a recon v2 workflow config.
+ * When leftDataset/rightDataset are provided, the backing workbook's
+ * primary/secondary sheet is rewired to the dataset and the workflow's
+ * leftDef/rightDef ImportDefs are rebuilt server-side. The workflow's
+ * `sources` are always kept in sync server-side — callers don't need to
+ * (and shouldn't) compute them.
  * Note: V2 settings stored on the workbook (customFields.reconV2 — currency,
  * exceptionGroups, policies, prompts) are updated via workbook.saveWorkbook.
  * @param params - The update parameters
  * @param params.reconWorkflow - Required: The workflow object with id
+ * @param params.leftDataset - Optional: Left dataset { id, name, dateColumn? }
+ * @param params.rightDataset - Optional: Right dataset { id, name, dateColumn? }
  * @returns Promise<ReconV2Workflow> The updated workflow
  * @throws Error if the request fails
  */
-export declare function updateReconV2({ reconWorkflow, }: UpdateReconV2Request): Promise<ReconV2Workflow>;
+export declare function updateReconV2({ reconWorkflow, leftDataset, rightDataset, }: UpdateReconV2Request): Promise<ReconV2Workflow>;

package/dist/index.d.ts

@@ -10,10 +10,11 @@ export type { AuditRecord, CreateAuditLogRequest, } from './api/audit/createAudi
 export type { TemplatedPipelineWorkflow, GetAllTemplatedPipelinesResponse, } from './api/templatedPipeline/getAllTemplatedPipelines';
 export type { ReconWorkflow } from './api/recon/getAllReconWorkflows';
 export type { RunReconRequest, RunReconResponse } from './api/recon/runRecon';
-export type { ReconV2Workflow, CreateReconV2Request, } from './api/reconV2/createReconV2';
+export type { ReconV2Workflow, ReconV2DatasetRef, CreateReconV2Request, } from './api/reconV2/createReconV2';
 export type { UpdateReconV2Request } from './api/reconV2/updateReconV2';
 export type { DeleteReconV2Request, DeleteReconV2Response, } from './api/reconV2/deleteReconV2';
 export type { ReconV2MatchConfig, RunReconV2Request, RunReconV2Response, } from './api/reconV2/runReconV2';
+export type { GetReconV2RunsRequest, ReconV2Run, } from './api/reconV2/getReconV2Runs';
 export type { GetReconV2RunResultRequest, ReconV2RunResult, } from './api/reconV2/getReconV2RunResult';
 export type { GetReconV2SmartResultRequest, ReconV2SmartResult, } from './api/reconV2/getReconV2SmartResult';
 export type { ReconV2ProfileRequest, ReconV2ProfileResult, } from './api/reconV2/profileReconV2';
@@ -64,3 +65,24 @@ export type { TcnFtpManualDialReport } from './api/tcn/ftpManualDialReport';
 export type { FilterOnSenderId, EmailMessage, PageChunkEmailMessage, } from './api/emailEngine/getMessageBySenderId';
 export type { EmailMessageSearchRequest, } from './api/emailEngine/searchMessages';
 export type { RenderTemplateRequest, RenderTemplateResponse, RenderTemplateWarning, TemplateEngine, } from './api/templates/render';
+export type { DataboxFile, DataboxFileStatus, DataboxFolder, DataboxFileProcessingResult, DataboxSchemaUpdateResult, DataboxFolderSchema, DataboxFileDownloadUrl, DataboxDataset, DataboxDatasetDuplicates, } from './api/databox/types';
+export type { GetDataboxFolderDatasetsRequest } from './api/databox/getDataboxFolderDatasets';
+export type { GetDataboxFolderDuplicatesRequest } from './api/databox/getDataboxFolderDuplicates';
+export type { GetDatasetExceptionsRequest, DatasetExceptions, } from './api/dataset/getDatasetExceptions';
+export type { GetDatasetDuplicatesRequest, DatasetDuplicates, } from './api/dataset/getDatasetDuplicates';
+export { DATABOX_SUPPORTED_EXTENSIONS } from './api/databox/types';
+export type { GetDataboxFolderRequest } from './api/databox/getDataboxFolder';
+export type { GetDataboxFolderFilesRequest } from './api/databox/getDataboxFolderFiles';
+export type { DropFileToDataboxRequest } from './api/databox/dropFileToDatabox';
+export type { RunDataboxFolderRequest } from './api/databox/runDataboxFolder';
+export type { GetDataboxFolderSchemaRequest } from './api/databox/getDataboxFolderSchema';
+export type { UpdateDataboxFolderSchemaRequest } from './api/databox/updateDataboxFolderSchema';
+export type { GetDataboxSchemaHistoryRequest } from './api/databox/getDataboxSchemaHistory';
+export type { GetDataboxTrashFilesRequest } from './api/databox/getDataboxTrashFiles';
+export type { GetDataboxFileRequest } from './api/databox/getDataboxFile';
+export type { GetDataboxFileStatusRequest } from './api/databox/getDataboxFileStatus';
+export type { GetDataboxFileRunsRequest } from './api/databox/getDataboxFileRuns';
+export type { GetDataboxFileDownloadUrlRequest } from './api/databox/getDataboxFileDownloadUrl';
+export type { TrashDataboxFilesRequest } from './api/databox/trashDataboxFiles';
+export type { RestoreDataboxFileRequest } from './api/databox/restoreDataboxFile';
+export type { PermanentDeleteDataboxFilesRequest } from './api/databox/permanentDeleteDataboxFiles';