@flosum/salesforce 1.17.11-beta.0 → 1.17.11-beta.2

package/dist/typings/classes/list-metadata/document.folder-dependent.list-metadata.d.ts

@@ -0,0 +1,7 @@
+import BaseFolderDependentListMetadata, { FolderListMetadataOptions } from './base.folder-dependent.list-metadata';
+import BaseFolderListMetadata from './base.folder.list-metadata';
+import { MetadataItemData } from '../../interfaces';
+export default class DocumentFolderDependentListMetadata extends BaseFolderDependentListMetadata {
+    protected createFolderListMetadata(options: FolderListMetadataOptions): BaseFolderListMetadata;
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/document.folder.list-metadata.d.ts

@@ -0,0 +1,5 @@
+import { DescribeMetadataItem, MetadataItemData } from '../../interfaces';
+import DefaultFolderListMetadata from './default.folder.list-metadata';
+export default class DocumentFolderListMetadata extends DefaultFolderListMetadata {
+    listMetadataFolder(describeItem: DescribeMetadataItem): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/duplicate-rule.list-metadata.d.ts

@@ -0,0 +1,12 @@
+import { DescribeMetadataItem, MetadataItemData } from '../../interfaces';
+import BaseListMetadata, { BaseListMetadataOptions } from './base.list-metadata';
+export declare type DuplicateRuleListMetadataOptions = {
+    describeItem: DescribeMetadataItem;
+} & BaseListMetadataOptions;
+export default class DuplicateRuleListMetadata extends BaseListMetadata {
+    protected readonly describeItem: DescribeMetadataItem;
+    constructor({ describeItem, ...baseOptions }: DuplicateRuleListMetadataOptions);
+    private getPersonDuplicateRules;
+    private handlePersonAccounts;
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/installed-packages.list-metadata.d.ts

@@ -0,0 +1,15 @@
+import { DescribeMetadataItem, MetadataItemData } from '../../interfaces';
+import { Logger } from '../../interfaces/logger.interfaces';
+import BaseListMetadata from './base.list-metadata';
+import { AxiosInstance } from 'axios';
+export default class InstalledPackagesListMetadata extends BaseListMetadata {
+    protected readonly describeItem: DescribeMetadataItem;
+    constructor({ describeItem, ...baseOptions }: {
+        apiVersion: string;
+        axiosInstance: AxiosInstance;
+        logger: Logger;
+        describeItem: DescribeMetadataItem;
+    });
+    private getInstalledSubscriberPackages;
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/manager.list-metadata.d.ts

@@ -0,0 +1,24 @@
+import { DescribeMetadataResult, ListMetadataItem, ListMetadataItemDetails } from '../../interfaces';
+import { Logger } from '../../interfaces/logger.interfaces';
+import { AxiosInstance } from 'axios';
+export declare type ManagerListMetadataOptions = {
+    apiVersion: string;
+    axiosInstance: AxiosInstance;
+    describeMetadata: DescribeMetadataResult;
+    logger: Logger;
+    filter?: (listMetadataItem: ListMetadataItem) => boolean;
+};
+export default class ManagerListMetadata {
+    private _apiVersion;
+    private _axiosInstance;
+    private _describeMetadata;
+    private _logger;
+    private _filter?;
+    private _itemsByUniqueName;
+    private _describeByType;
+    constructor({ apiVersion, axiosInstance, describeMetadata, logger, filter }: ManagerListMetadataOptions);
+    private runListMetadata;
+    private setToItemsByUniqueName;
+    private isChildType;
+    execute(): Promise<ListMetadataItemDetails[]>;
+}

package/dist/typings/classes/list-metadata/record-types.list-metadata.d.ts

@@ -0,0 +1,7 @@
+import BaseListMetadata from './base.list-metadata';
+import { MetadataItemData } from '../../interfaces';
+export default class RecordTypesListMetadata extends BaseListMetadata {
+    private getPersonRecordTypes;
+    private handlePersonRecordTypes;
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/sharing-rule-children.list.metadata.d.ts

@@ -0,0 +1,10 @@
+import { DescribeMetadataItem, MetadataItemData } from '../../interfaces';
+import BaseListMetadata, { BaseListMetadataOptions } from './base.list-metadata';
+export declare type SharingRuleChildrenListMetadataOptions = {
+    describeItem: DescribeMetadataItem[];
+} & BaseListMetadataOptions;
+export default class SharingRuleChildrenListMetadata extends BaseListMetadata {
+    protected readonly describeItem: SharingRuleChildrenListMetadataOptions['describeItem'];
+    constructor({ describeItem, ...baseOptions }: SharingRuleChildrenListMetadataOptions);
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/standard-value-set.list-metadata.d.ts

@@ -0,0 +1,5 @@
+import BaseListMetadata from './base.list-metadata';
+import { MetadataItemData } from '../../interfaces';
+export default class StandardValueSetListMetadata extends BaseListMetadata {
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/list-metadata/synonym-dictionary.list-metadata.d.ts

@@ -0,0 +1,10 @@
+import BaseListMetadata, { BaseListMetadataOptions } from './base.list-metadata';
+import { DescribeMetadataItem, MetadataItemData } from '../../interfaces';
+export declare type SynonymDictionaryListMetadataOptions = BaseListMetadataOptions & {
+    describeItem: DescribeMetadataItem;
+};
+export default class SynonymDictionaryListMetadata extends BaseListMetadata {
+    protected readonly describeItem: SynonymDictionaryListMetadataOptions['describeItem'];
+    constructor({ describeItem, ...baseOptions }: SynonymDictionaryListMetadataOptions);
+    execute(): Promise<MetadataItemData[]>;
+}

package/dist/typings/classes/metadata-xml-stream-parser.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Transform, TransformCallback } from 'stream';
+export default class MetadataXmlStreamParser extends Transform {
+    private readonly parser;
+    private isParseZip;
+    private resultXml;
+    private binaryValue;
+    private binaryRemainder;
+    private zipFile;
+    constructor();
+    private init;
+    private handleStartElement;
+    private handleText;
+    private handleEndElement;
+    private convertChunkBase64ToBuffer;
+    _transform(chunk: string, _: BufferEncoding, callback: TransformCallback): Promise<void>;
+    _flush(callback: TransformCallback): Promise<void>;
+}

package/dist/typings/classes/permissions/factory.permissions.d.ts

@@ -0,0 +1,6 @@
+import { PermissionComponent } from '../../interfaces';
+import { BasePermissionsHandler } from './handlers/base-permissions.handler';
+import { PermissionCategory } from '../../enums';
+export default class FactoryPermissions {
+    static create(key: PermissionCategory | string, data: PermissionComponent, components: Map<string, Set<string>>): BasePermissionsHandler;
+}

package/dist/typings/classes/permissions/handlers/application-visibilities.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class ApplicationVisibilitiesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/base-permissions.handler.d.ts

@@ -0,0 +1,11 @@
+import { PermissionComponent } from '../../../interfaces';
+export declare type BasePermissionsHandlerOptions = {
+    data: PermissionComponent;
+    components: Map<string, Set<string>>;
+};
+export declare abstract class BasePermissionsHandler {
+    protected readonly data: BasePermissionsHandlerOptions['data'];
+    protected readonly components: BasePermissionsHandlerOptions['components'];
+    constructor({ data, components }: BasePermissionsHandlerOptions);
+    abstract execute(): void;
+}

package/dist/typings/classes/permissions/handlers/category-group-visibilities.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class CategoryGroupVisibilitiesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/class-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class ClassAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/custom-metadata-type-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class CustomMetadataTypeAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/custom-permissions.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class CustomPermissionsHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/custom-settings-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class CustomSettingsAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/external-data-source-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class ExternalDataSourceAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/field-permissions.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class FieldPermissionsHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/flow-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class FlowAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/layout-assignments.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class LayoutAssignmentsHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/object-permissions.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class ObjectPermissionsHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/page-accesses.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class PageAccessesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/profile-action-overrides.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class ProfileActionOverridesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/record-type-visibilities.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class RecordTypeVisibilitiesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/tab-settings.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class TabSettingsHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/handlers/tab-visibilities.handler.d.ts

@@ -0,0 +1,4 @@
+import { BasePermissionsHandler } from './base-permissions.handler';
+export declare class TabVisibilitiesHandler extends BasePermissionsHandler {
+    execute(): void;
+}

package/dist/typings/classes/permissions/permissions-manager.d.ts

@@ -0,0 +1,13 @@
+import { MetadataType } from '../../enums';
+export declare type PermissionsManagerOptions = {
+    content: string;
+    type: MetadataType | string;
+    components: Map<MetadataType | string, Set<string>>;
+};
+export default class PermissionsManager {
+    protected readonly content: PermissionsManagerOptions['content'];
+    protected readonly type: PermissionsManagerOptions['type'];
+    protected readonly components: PermissionsManagerOptions['components'];
+    constructor({ content, type, components }: PermissionsManagerOptions);
+    execute(): string;
+}

package/dist/typings/classes/pk-chunking.d.ts

@@ -0,0 +1,12 @@
+export declare type PKChunk = [string, string];
+export declare type PKChunks = PKChunk[];
+export default class PkChunking {
+    private static createRanges;
+    private static convertBase62ToId;
+    private static convertRangesToPKChunks;
+    /**
+     * Method to create PK ranges based on first and last id's
+     * @returns array containing array with [startId, endId]
+     */
+    static makeRanges(firstId: string, lastId: string, chunkSize?: number): PKChunks;
+}

package/dist/typings/classes/pk-chunking.fixtures.d.ts

@@ -0,0 +1,5 @@
+export declare const ID_PREFIX = "00PJ00";
+export declare const ID_LENGTH = 15;
+export declare function addLeadingZeros(input: string, count: number): string;
+export declare function numberToId(input: number): string;
+export declare function idToNumber(input: string): number;

package/dist/typings/classes/query-builder.d.ts

@@ -0,0 +1,80 @@
+import { SortDirection } from '../enums/query.enums';
+import ClauseBuilder from './clause-builder';
+declare type OrderItem = [string, SortDirection];
+declare type QueryBuilderOptions = {
+    throwOnSizeExceeded?: boolean;
+    maxSize?: number;
+};
+/**
+ * QueryBuilder is an util class which builds simple queries for Salesforce
+ * @example
+ * const builder = new QueryBuilder()
+ *  .select('Id', 'Name')
+ *  .from('Account')
+ *  .where('Id >= :startId', { startId: '00PJ000000A78cnMAB' })
+ *  .andWhere('Name = 'John')
+ *  .limit(2000)
+ *  .orderBy(['Id', SortDirection.ASC])
+ *
+ * const query = builder.build();
+ * // SELECT Id, Name FROM Account WHERE Id >= '00PJ000000A78cnMAB' AND Name = 'John' ORDER BY Id ASC LIMIT 2000
+ */
+export default class QueryBuilder {
+    private _fields;
+    private _object;
+    private _orders;
+    private _limit;
+    private _clauseBuilder;
+    private buildOrders;
+    private buildBaseSelect;
+    private buildLimit;
+    private buildClauses;
+    hasLimit(): boolean;
+    hasOrders(): boolean;
+    /**
+     * Specify field to select
+     * @param fields a list of fields separated by comma
+     * @example
+     * builder.select('Id', 'Name')
+     */
+    select(...fields: string[]): QueryBuilder;
+    /**
+     * Specify object (table) to select from
+     * @param object object name
+     * @example
+     * builder.from('Account')
+     */
+    from(object: string): QueryBuilder;
+    /**
+     * Specify a limit for records to retrieve
+     * @param limit number of records to retrieve
+     * @example
+     * builder.limit(2000)
+     */
+    limit(limit: number): QueryBuilder;
+    /**
+     * Specify an order for records to retrieve
+     * @param orders list of orders
+     * @example
+     * builder.order(['Id', SortDirection.ASC], ['Name', SortDirection.DESC])
+     */
+    order(...orders: OrderItem[]): QueryBuilder;
+    where(clause: ClauseBuilder): QueryBuilder;
+    where(input: string, parameters?: Record<string, any>): QueryBuilder;
+    orWhere(clause: ClauseBuilder): QueryBuilder;
+    orWhere(input: string, parameters?: Record<string, any>): QueryBuilder;
+    andWhere(clause: ClauseBuilder): QueryBuilder;
+    andWhere(input: string, parameters?: Record<string, any>): QueryBuilder;
+    copy(): QueryBuilder;
+    clearClause(): QueryBuilder;
+    /**
+     * Build an actual query from specified properties
+     * @param encodeUri if true then returns encoded string to be used in requests
+     * @param throwOnSizeExceeded if true then throw an exception if the query length is greater than maxSize
+     * @param maxSize limit on the maximum length of a query
+     * @example
+     * builder.select('Id').from('Account').build() // SELECT Id FROM Account
+     */
+    build(encodeUri?: boolean, { throwOnSizeExceeded, maxSize }?: QueryBuilderOptions): string;
+}
+export {};

package/dist/typings/classes/read-metadata-xml.parser.d.ts

@@ -0,0 +1,18 @@
+import { ReadMetadataRecord } from '../interfaces/metadata/read-metadata.interfaces';
+import { MetadataType } from '../enums';
+export declare type ReadMetadataXmlParserOptions = {
+    type: MetadataType | string;
+    organizationNamespace?: string;
+};
+export declare type ReadMetadataXmlParserResult = {
+    fullName: string;
+    xml: string;
+    type: MetadataType | string;
+};
+export declare class ReadMetadataXmlParser {
+    private readonly type;
+    private readonly organizationNamespace;
+    constructor({ type, organizationNamespace }: ReadMetadataXmlParserOptions);
+    execute(record: ReadMetadataRecord): ReadMetadataXmlParserResult;
+    private removeNamespace;
+}

package/dist/typings/classes/retrieve-binary/apex-rest-retrieve-binary.d.ts

@@ -0,0 +1,8 @@
+import BaseRetrieveBinary from './base-retrieve-binary';
+import { RetrieveBinaryRequestApexRest, RetrieveBinaryResult } from '../../interfaces/retrieve-binary.interfaces';
+export default class ApexRestRetrieveBinary extends BaseRetrieveBinary {
+    private readonly endpoint;
+    constructor({ objectName, fields, instance, endpoint }: RetrieveBinaryRequestApexRest);
+    execute(recordsId: string[]): Promise<RetrieveBinaryResult[]>;
+    private convertBase64toStreams;
+}

package/dist/typings/classes/retrieve-binary/base-retrieve-binary.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { RetrieveBinaryResult } from '../../interfaces/retrieve-binary.interfaces';
+import { ApiCallsCounter } from '../api-calls-counter';
+export default abstract class BaseRetrieveBinary {
+    protected readonly objectName: string;
+    protected readonly fields: string[];
+    protected readonly instance: AxiosInstance;
+    protected readonly apiCallsCounter: ApiCallsCounter;
+    constructor(objectName: string, fields: string[], instance: AxiosInstance);
+    getApiCallsCount(): number;
+    abstract execute(recordsId: string[]): Promise<RetrieveBinaryResult[]>;
+}

package/dist/typings/classes/retrieve-binary/rest-retrieve-binary.d.ts

@@ -0,0 +1,7 @@
+import BaseRetrieveBinary from './base-retrieve-binary';
+import { RetrieveBinaryRequestRest, RetrieveBinaryResult } from '../../interfaces/retrieve-binary.interfaces';
+export default class RestRetrieveBinary extends BaseRetrieveBinary {
+    private readonly api;
+    constructor({ objectName, fields, instance, api }: RetrieveBinaryRequestRest);
+    execute([recordId]: string[]): Promise<RetrieveBinaryResult[]>;
+}

package/dist/typings/classes/retrieve-binary/rich-text-image-retrieve-binary.d.ts

@@ -0,0 +1,10 @@
+import { RetrieveBinaryResult, RetrieveRichTextImage } from '../../interfaces';
+import BaseRetrieveBinary from './base-retrieve-binary';
+export default class RichTextImageRetrieveBinary extends BaseRetrieveBinary {
+    private readonly api;
+    private readonly recordId;
+    private readonly richTextField;
+    private readonly refId;
+    constructor({ instance, api, objectName, recordId, richTextField, refId }: RetrieveRichTextImage);
+    execute(): Promise<RetrieveBinaryResult[]>;
+}

package/dist/typings/classes/retrieve-data/base-retrieve-data.d.ts

@@ -0,0 +1,17 @@
+import { AxiosInstance } from 'axios';
+import QueryBuilder from '../query-builder';
+import { Logger } from '../../interfaces/logger.interfaces';
+import { ApiCallsCounter } from '../api-calls-counter';
+export default abstract class BaseRetrieveData<T> {
+    protected readonly instance: AxiosInstance;
+    protected readonly logger?: Logger;
+    protected readonly queryBuilder: QueryBuilder;
+    protected isDone: boolean;
+    protected numberRetrievedRecords: number;
+    protected apiCallsCounter: ApiCallsCounter;
+    getIsDone(): boolean;
+    getApiCallsCount(): number;
+    protected constructor(instance: AxiosInstance, queryBuilder: QueryBuilder, logger?: Logger);
+    abstract execute(): Promise<T>;
+    protected isExecutable(): void;
+}

package/dist/typings/classes/retrieve-data/bulk1/base-bulk1-batch.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { AxiosInstance } from 'axios';
+import { Bulk1BatchDetails, Logger } from '../../../interfaces';
+import { BulkV1QueryContentType } from '../../../enums';
+import QueryBuilder from '../../query-builder';
+import stream from 'stream';
+import { ApiCallsCounter } from '../../api-calls-counter';
+export interface BaseBulk1BatchPayload {
+    instance: AxiosInstance;
+    api: string;
+    objectName: string;
+    logger: Logger;
+    jobId: string;
+    contentType: BulkV1QueryContentType;
+    pathTmp: string;
+    queryBuilder?: QueryBuilder;
+    apiCallsCounter?: ApiCallsCounter;
+}
+export declare abstract class BaseBulk1Batch {
+    protected readonly api: string;
+    protected readonly objectName: string;
+    private readonly contentType;
+    private readonly encryptionKey;
+    private readonly pathTmp;
+    protected readonly instance: AxiosInstance;
+    protected readonly logger: Logger;
+    protected readonly apiCallsCounter: ApiCallsCounter;
+    private _id;
+    private _state;
+    private _stateMessage;
+    private _queryBuilder;
+    private _resultIds;
+    private _numberRecordsProcessed;
+    private _jobId;
+    get id(): string;
+    get state(): string;
+    get jobId(): string;
+    set state(state: string);
+    set jobId(jobId: string);
+    get numberRecordsProcessed(): number;
+    set numberRecordsProcessed(recordsProcessed: number);
+    set stateMessage(stateMessage: string);
+    get stateMessage(): string;
+    get isDone(): boolean;
+    constructor({ instance, api, objectName, logger, jobId, contentType, pathTmp, queryBuilder, apiCallsCounter, }: BaseBulk1BatchPayload);
+    abstract splitBatch(): AsyncGenerator<string[]>;
+    updateDetails(): Promise<void>;
+    create(): Promise<void>;
+    init({ id, state, stateMessage }: Bulk1BatchDetails): Promise<void>;
+    getResult(): Promise<stream.Readable>;
+    updateResultIds(): Promise<void>;
+    private writeToTmp;
+    private deleteFile;
+}

package/dist/typings/classes/retrieve-data/bulk1/base-bulk1-retrieve-data.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import BaseRetrieveData from '../base-retrieve-data';
+import stream from 'stream';
+import { Bulk1JobOperation, BulkV1QueryContentType } from '../../../enums';
+import { RetrieveRequestBulk1 } from '../../../interfaces';
+import { BaseBulk1Batch, BaseBulk1BatchPayload } from './base-bulk1-batch';
+import { AxiosRequestConfig } from 'axios';
+export declare abstract class BaseBulk1RetrieveData extends BaseRetrieveData<stream.Readable | null> {
+    protected readonly objectName: string;
+    protected readonly api: string;
+    protected readonly pollInterval: number;
+    protected readonly contentType: BulkV1QueryContentType;
+    protected readonly jobOperation: Bulk1JobOperation;
+    protected readonly pathTmp: string;
+    protected jobId: string;
+    protected completedBatch: BaseBulk1Batch;
+    protected bulk1Batches: Map<string, BaseBulk1Batch>;
+    constructor({ instance, api, pollInterval, queryBuilder, objectName, contentType, jobOperation, logger, tmpPath, }: RetrieveRequestBulk1);
+    protected get createBulk1JobConfig(): AxiosRequestConfig;
+    protected get baseBulk1BatchPayload(): BaseBulk1BatchPayload;
+    protected abstract init(): Promise<void>;
+    execute(): Promise<stream.Readable | null>;
+    closeJob(): Promise<void>;
+    private fetchStateBatches;
+    protected getNextCompletedBatch(): Promise<void>;
+    protected createJob(): Promise<void>;
+    private handleFailedBatch;
+    private createBatchForChunk;
+}

package/dist/typings/classes/retrieve-data/bulk1/bulk1-batch-factory.d.ts

@@ -0,0 +1,5 @@
+import { BaseBulk1Batch } from './base-bulk1-batch';
+import { Bulk1ByIdBatchPayload } from './bulk1-retrive-by-id/bulk1-by-id-batch';
+export declare class Bulk1BatchFactory {
+    static create({ ids, ...batchPayload }: Bulk1ByIdBatchPayload): BaseBulk1Batch;
+}

package/dist/typings/classes/retrieve-data/bulk1/bulk1-pk-retrive/bulk1-pk-retrieve-data.d.ts

@@ -0,0 +1,16 @@
+import { RetrieveRequestBulk1PK } from '../../../../interfaces/retrieve.interfaces';
+import { BaseBulk1RetrieveData } from '../base-bulk1-retrieve-data';
+import { AxiosRequestConfig } from 'axios';
+export default class Bulk1PkRetrieveData extends BaseBulk1RetrieveData {
+    private readonly chunkSize;
+    private baseBatch;
+    private isPkChunking;
+    constructor({ chunkSize, ...baseOptions }: RetrieveRequestBulk1PK);
+    protected get createBulk1JobConfig(): AxiosRequestConfig;
+    init(): Promise<void>;
+    private splitFailedBaseBatch;
+    private createBaseBatch;
+    private waitToCompleteBaseBatch;
+    private processFailedBaseBatch;
+    private getAllBatches;
+}

package/dist/typings/classes/retrieve-data/bulk1/bulk1-retrive/bulk1-retrieve-data.d.ts

@@ -0,0 +1,5 @@
+import { BaseBulk1RetrieveData } from '../base-bulk1-retrieve-data';
+export default class Bulk1RetrieveData extends BaseBulk1RetrieveData {
+    init(): Promise<void>;
+    private createBatch;
+}

package/dist/typings/classes/retrieve-data/bulk1/bulk1-retrive-by-id/bulk1-by-id-batch.d.ts

@@ -0,0 +1,10 @@
+import { BaseBulk1Batch } from '../base-bulk1-batch';
+import { BaseBulk1BatchPayload } from '../base-bulk1-batch';
+export interface Bulk1ByIdBatchPayload extends BaseBulk1BatchPayload {
+    ids: string[];
+}
+export declare class Bulk1ByIdBatch extends BaseBulk1Batch {
+    private readonly ids;
+    constructor({ ids, ...basePayload }: Bulk1ByIdBatchPayload);
+    splitBatch(): AsyncGenerator<string[]>;
+}

package/dist/typings/classes/retrieve-data/bulk1/bulk1-retrive-by-id/bulk1-retrieve-by-id.d.ts

@@ -0,0 +1,7 @@
+import { RetrieveRequestBulk1ById } from '../../../../interfaces';
+import { BaseBulk1RetrieveData } from '../base-bulk1-retrieve-data';
+export default class Bulk1RetrieveById extends BaseBulk1RetrieveData {
+    private readonly chunks;
+    constructor({ chunks, ...baseOptions }: RetrieveRequestBulk1ById);
+    protected init(): Promise<void>;
+}

package/dist/typings/classes/retrieve-data/bulk1/simple-bulk1-batch.d.ts

@@ -0,0 +1,8 @@
+import { BaseBulk1Batch } from './base-bulk1-batch';
+export declare class SimpleBulk1Batch extends BaseBulk1Batch {
+    splitBatch(): AsyncGenerator<string[]>;
+    private getRequestedObjectRecords;
+    private compositeRequest;
+    private getSplitQueryBuilder;
+    private getRequestedObjectIds;
+}

package/dist/typings/classes/retrieve-data/bulk2-retrieve-data.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { RetrieveRequestBulk2 } from '../../interfaces/retrieve.interfaces';
+import BaseRetrieveData from './base-retrieve-data';
+import * as stream from 'stream';
+export default class Bulk2RetrieveData extends BaseRetrieveData<stream.Readable | null> {
+    private readonly pollInterval;
+    private readonly maxRecords;
+    private readonly api;
+    private jobId;
+    private queryLocator;
+    private get query();
+    constructor({ instance, queryBuilder, pollInterval, maxRecords, api, logger }: RetrieveRequestBulk2);
+    private get requestResultConfig();
+    execute(): Promise<stream.Readable | null>;
+    abortedJob(): Promise<void>;
+    private waitToCompleteJob;
+}

package/dist/typings/classes/retrieve-data/bulk2-retrieve-data.fixtures.d.ts

@@ -0,0 +1,8 @@
+import { Bulk2JobQuery, Bulk2JobQueryStatus } from '../../interfaces/bulk2.interfaces';
+export declare const jobId = "750R0000000zlh9IAA";
+export declare const sforceLocator = "MTAwMDA";
+export declare const createBulkJobQueryResponse: Bulk2JobQuery;
+export declare const statusBulkJonQueryInProgressResponse: Bulk2JobQueryStatus;
+export declare const statusBulkJonQueryCompletedResponse: Bulk2JobQueryStatus;
+export declare const testRecordsChunkOne = "Id,Name\n1,Test 1\n2,Test 2\n3,Test 3\n4,Test 4\n5,Test 5\n6,Test 6\n7,Test 7\n8,Test 8\n9,Test 9\n10,Test 10";
+export declare const testRecordsChunkTwo = "Id,Name\n11,Test 11\n12,Test 12";