@salesforce/lds-adapters-industries-filebased-dataimport 0.1.0-dev1

package/dist/es/es2018/types/src/generated/types/FileBasedDataImportRepresentation.d.ts

@@ -0,0 +1,91 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d31c2d618b5ff6607036493cc0a3cca4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    id: string;
+}
+export type FileBasedDataImportRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialFileBasedDataImportRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): FileBasedDataImportRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: FileBasedDataImportRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: FileBasedDataImportRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: FileBasedDataImportRepresentation, existing: FileBasedDataImportRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FileBasedDataImportRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FileBasedDataImportRepresentationNormalized, incoming: FileBasedDataImportRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FileBasedDataImportRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * File based Data import Entity output representation
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface FileBasedDataImportRepresentationNormalized {
+    /** createdBy */
+    createdBy?: string;
+    /** createdDate */
+    createdDate?: string;
+    /** FailedRecordsCount */
+    failedRecordsCount?: number;
+    /** FailedResults */
+    failedResults?: string | null;
+    /** FileBasedImportType */
+    fileBasedImportType: string;
+    /** ID */
+    id: string;
+    /** ImportOperationType */
+    importOperationType: string;
+    /** JobIdentifier */
+    jobIdentifier?: string | null;
+    /** lastModifiedDate */
+    lastModifiedDate?: string;
+    /** ParentJobId */
+    parentJobId?: string | null;
+    /** SourceContentDocument */
+    sourceContentDocument?: string | null;
+    /** SourceFileName */
+    sourceFileName: string;
+    /** Status */
+    status: string;
+    /** StatusReason */
+    statusReason?: string | null;
+    /** SuccessRecordsCount */
+    successRecordsCount?: number;
+    /** SuccessfulResults */
+    successfulResults?: string | null;
+    /** TargetContext */
+    targetContext?: string | null;
+    /** UnprocessedRecords */
+    unprocessedRecords?: string | null;
+    /** UnprocessedRecordsCount */
+    unprocessedRecordsCount?: number;
+}
+/**
+ * File based Data import Entity output representation
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface FileBasedDataImportRepresentation {
+    createdBy?: string;
+    createdDate?: string;
+    failedRecordsCount?: number;
+    failedResults?: string | null;
+    fileBasedImportType: string;
+    id: string;
+    importOperationType: string;
+    jobIdentifier?: string | null;
+    lastModifiedDate?: string;
+    parentJobId?: string | null;
+    sourceContentDocument?: string | null;
+    sourceFileName: string;
+    status: string;
+    statusReason?: string | null;
+    successRecordsCount?: number;
+    successfulResults?: string | null;
+    targetContext?: string | null;
+    unprocessedRecords?: string | null;
+    unprocessedRecordsCount?: number;
+}

package/dist/es/es2018/types/src/generated/types/FileBasedDataImportUpdateInputRep.d.ts

@@ -0,0 +1,67 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "d8775d80be071a24794c2eae163c51ed";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FileBasedDataImportUpdateInputRep, existing: FileBasedDataImportUpdateInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FileBasedDataImportUpdateInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FileBasedDataImportUpdateInputRepNormalized, incoming: FileBasedDataImportUpdateInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FileBasedDataImportUpdateInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for File Based Data Import
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FileBasedDataImportUpdateInputRepNormalized {
+    /** The failed record content doc of the file based data import functionality entity */
+    failedRecordContentDoc?: string;
+    /** The failed record count of the file based data import functionality entity */
+    failedRecordCount?: number;
+    /** The importOperationType of the file based data import functionality entity */
+    importOperationType?: string;
+    /** The importType of the file based data import functionality entity */
+    importType?: string;
+    /** The job identifier of the file based data import functionality entity */
+    jobIdentifier?: string;
+    /** The sourceContentDocument of the file based data import functionality entity */
+    sourceContentDocument?: string;
+    /** The sourceFileName of the file based data import functionality entity */
+    sourceFileName?: string;
+    /** The status of the file based data import functionality entity */
+    status?: string;
+    /** The status reason of the file based data import functionality entity */
+    statusReason?: string;
+    /** The successful record content doc of the file based data import functionality entity */
+    successfulRecordContentDoc?: string;
+    /** The successful record count  of the file based data import functionality entity */
+    successfulRecordCount?: number;
+    /** The targetContext of the file based data import functionality entity */
+    targetContext?: string;
+    /** The unprocessed record content doc of the file based data import functionality entity */
+    unprocessedRecordContentDoc?: string;
+    /** The unprocessed record count of the file based data import functionality entity */
+    unprocessedRecordCount?: number;
+}
+/**
+ * Input representation for File Based Data Import
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FileBasedDataImportUpdateInputRep {
+    failedRecordContentDoc?: string;
+    failedRecordCount?: number;
+    importOperationType?: string;
+    importType?: string;
+    jobIdentifier?: string;
+    sourceContentDocument?: string;
+    sourceFileName?: string;
+    status?: string;
+    statusReason?: string;
+    successfulRecordContentDoc?: string;
+    successfulRecordCount?: number;
+    targetContext?: string;
+    unprocessedRecordContentDoc?: string;
+    unprocessedRecordCount?: number;
+}

package/dist/es/es2018/types/src/generated/types/FileImportInputRepresentation.d.ts

@@ -0,0 +1,34 @@
+import { ImportOptionsInputRepresentation as ImportOptionsInputRepresentation_ImportOptionsInputRepresentation } from './ImportOptionsInputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "10bbd8a200f443b9c3e9bc90881ff72e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: FileImportInputRepresentation, existing: FileImportInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FileImportInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FileImportInputRepresentationNormalized, incoming: FileImportInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FileImportInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of payload for File Based Data Import Use Case
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FileImportInputRepresentationNormalized {
+    /** The id of the file based data import functionality entity */
+    importReferenceId: string;
+    options?: ImportOptionsInputRepresentation_ImportOptionsInputRepresentation;
+    /** The target context of import be it a object or a import template */
+    targetContext: string;
+}
+/**
+ * Input representation of payload for File Based Data Import Use Case
+ *
+ * Keys:
+ *    (none)
+ */
+export interface FileImportInputRepresentation {
+    importReferenceId: string;
+    options?: ImportOptionsInputRepresentation_ImportOptionsInputRepresentation;
+    targetContext: string;
+}

package/dist/es/es2018/types/src/generated/types/FileImportOutputRepresentation.d.ts

@@ -0,0 +1,40 @@
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "0f74d1482de21ff21d94491b9f9b869a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    statusCode: string;
+}
+export type FileImportOutputRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialFileImportOutputRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): FileImportOutputRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: FileImportOutputRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: FileImportOutputRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: FileImportOutputRepresentation, existing: FileImportOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FileImportOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: FileImportOutputRepresentationNormalized, incoming: FileImportOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: FileImportOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of a File Based Import Job
+ *
+ * Keys:
+ *    statusCode (string): statusCode
+ */
+export interface FileImportOutputRepresentationNormalized {
+    /** The status code of the Start Import Job API */
+    statusCode: string;
+    /** The status message of the Start Import Job API */
+    statusMessage: string;
+}
+/**
+ * Output representation of a File Based Import Job
+ *
+ * Keys:
+ *    statusCode (string): statusCode
+ */
+export interface FileImportOutputRepresentation {
+    statusCode: string;
+    statusMessage: string;
+}

package/dist/es/es2018/types/src/generated/types/ImportOperationInputRepresentation.d.ts

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "81dca5ace98d11cb047863a37c79101e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ImportOperationInputRepresentation, existing: ImportOperationInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ImportOperationInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ImportOperationInputRepresentationNormalized, incoming: ImportOperationInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ImportOperationInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of operations for File Based Import Case
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ImportOperationInputRepresentationNormalized {
+    /** The operation type of the import job */
+    operationType?: string;
+    /** The unique fields of the object on which Update or upsert kind of operations are to be performed */
+    uniqueFields?: Array<string>;
+}
+/**
+ * Input representation of operations for File Based Import Case
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ImportOperationInputRepresentation {
+    operationType?: string;
+    uniqueFields?: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/ImportOptionsInputRepresentation.d.ts

@@ -0,0 +1,39 @@
+import { FieldConfigurationInputRepresentation as FieldConfigurationInputRepresentation_FieldConfigurationInputRepresentation } from './FieldConfigurationInputRepresentation';
+import { ImportOperationInputRepresentation as ImportOperationInputRepresentation_ImportOperationInputRepresentation } from './ImportOperationInputRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "334e0dcff64ce4432848106b6022576e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ImportOptionsInputRepresentation, existing: ImportOptionsInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ImportOptionsInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ImportOptionsInputRepresentationNormalized, incoming: ImportOptionsInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ImportOptionsInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of Options for File Based Import
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ImportOptionsInputRepresentationNormalized {
+    /** The delimiter of the source content document */
+    delimiter?: string;
+    /** The End of Line character for the file used for import */
+    eol?: string;
+    /** The list of field configurations */
+    fieldConfigurations?: Array<FieldConfigurationInputRepresentation_FieldConfigurationInputRepresentation>;
+    /** The operation type of the import job */
+    operation?: ImportOperationInputRepresentation_ImportOperationInputRepresentation;
+}
+/**
+ * Input representation of Options for File Based Import
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ImportOptionsInputRepresentation {
+    delimiter?: string;
+    eol?: string;
+    fieldConfigurations?: Array<FieldConfigurationInputRepresentation_FieldConfigurationInputRepresentation>;
+    operation?: ImportOperationInputRepresentation_ImportOperationInputRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/ObjectInfoDirectoryEntryRepresentation.d.ts

@@ -0,0 +1,43 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "2e822aab70fdf6622a60bb733aa9b5bc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ObjectInfoDirectoryEntryRepresentation, existing: ObjectInfoDirectoryEntryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ObjectInfoDirectoryEntryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ObjectInfoDirectoryEntryRepresentationNormalized, incoming: ObjectInfoDirectoryEntryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ObjectInfoDirectoryEntryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Entry for an object info within the directory of objects.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryEntryRepresentationNormalized {
+    /** The API name of the object info corresponding to this entry. */
+    apiName: string;
+    /** The key prefix for IDs of this object. */
+    keyPrefix: string | null;
+    /** The label of the object info corresponding to this entry. */
+    label: string;
+    /** The plural label of the object info corresponding to this entry. */
+    labelPlural: string;
+    /** List of the API names of the fields used to identify the name field for standard and custom objects. Typically there is one name field per object, except where FirstName and LastName fields are used. */
+    nameFields: Array<string>;
+    /** The URL to retrieve the full object info corresponding to this entry. */
+    objectInfoUrl: string;
+}
+/**
+ * Entry for an object info within the directory of objects.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryEntryRepresentation {
+    apiName: string;
+    keyPrefix: string | null;
+    label: string;
+    labelPlural: string;
+    nameFields: Array<string>;
+    objectInfoUrl: string;
+}

package/dist/es/es2018/types/src/generated/types/ObjectInfoDirectoryRepresentation.d.ts

@@ -0,0 +1,33 @@
+import { ObjectInfoDirectoryEntryRepresentation as ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation } from './ObjectInfoDirectoryEntryRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "c040e955efdc64a496f748f728dcbe5f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ObjectInfoDirectoryRepresentation, existing: ObjectInfoDirectoryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ObjectInfoDirectoryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ObjectInfoDirectoryRepresentationNormalized, incoming: ObjectInfoDirectoryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ObjectInfoDirectoryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Directory of objects that can be used within UI API end-points.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryRepresentationNormalized {
+    /** The object info entries corresponding to the objects that can be used within UI API. */
+    objects: {
+        [key: string]: ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation;
+    };
+}
+/**
+ * Directory of objects that can be used within UI API end-points.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ObjectInfoDirectoryRepresentation {
+    objects: {
+        [key: string]: ObjectInfoDirectoryEntryRepresentation_ObjectInfoDirectoryEntryRepresentation;
+    };
+}

package/dist/es/es2018/types/src/generated/types/ReferenceEntityInfo.d.ts

@@ -0,0 +1,35 @@
+import { ReferenceFieldInfo as ReferenceFieldInfo_ReferenceFieldInfo } from './ReferenceFieldInfo';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "b3d49ed32b6dfdd7e4f99ef7e3629860";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ReferenceEntityInfo, existing: ReferenceEntityInfoNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ReferenceEntityInfoNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ReferenceEntityInfoNormalized, incoming: ReferenceEntityInfoNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ReferenceEntityInfo, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Referenced Entity info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ReferenceEntityInfoNormalized {
+    /** entityLabel */
+    entityLabel: string;
+    /** entityName */
+    entityName: string;
+    /** Entity id look up fields */
+    fields: Array<ReferenceFieldInfo_ReferenceFieldInfo>;
+}
+/**
+ * Referenced Entity info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ReferenceEntityInfo {
+    entityLabel: string;
+    entityName: string;
+    fields: Array<ReferenceFieldInfo_ReferenceFieldInfo>;
+}

package/dist/es/es2018/types/src/generated/types/ReferenceFieldInfo.d.ts

@@ -0,0 +1,31 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "79cbc962b5b6429d024e384c92f23cda";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ReferenceFieldInfo, existing: ReferenceFieldInfoNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ReferenceFieldInfoNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ReferenceFieldInfoNormalized, incoming: ReferenceFieldInfoNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ReferenceFieldInfo, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Referenced Field info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ReferenceFieldInfoNormalized {
+    /** fieldLabel */
+    fieldLabel: string;
+    /** fieldName */
+    fieldName: string;
+}
+/**
+ * Referenced Field info
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ReferenceFieldInfo {
+    fieldLabel: string;
+    fieldName: string;
+}

package/dist/es/es2018/types/src/generated/types/type-utils.d.ts

@@ -0,0 +1,32 @@
+import { NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const JSONStringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+type AllowedPrimitives = boolean | string | number | Date | null;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type RecursivePartial<T> = null | {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> | null : Value<T[P]> | null;
+};
+export declare function equalsArray<U, V extends U[]>(a: V, b: V, equalsItem: (itemA: U, itemB: U) => boolean | void): boolean;
+export declare function equalsObject<U, V extends {
+    [key: string]: U;
+}>(a: V, b: V, equalsProp: (propA: U, propB: U) => boolean | void): boolean;
+export declare function createLink(ref: string | $64$luvio_engine_NormalizedKeyMetadata): {
+    __ref: string;
+};
+export declare function assignMetadataLink(entry: any, metadataKey: string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export {};

package/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "@salesforce/lds-adapters-industries-filebased-dataimport",
+    "version": "0.1.0-dev1",
+    "description": "Resource Family for File Based Data Import Use cases",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "main": "dist/es/es2018/industries-filebased-dataimport.js",
+    "module": "dist/es/es2018/industries-filebased-dataimport.js",
+    "types": "dist/es/es2018/types/src/generated/artifacts/main.d.ts",
+    "files": [
+        "dist",
+        "sfdc",
+        "src/raml/*"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/es/es2018/types/src/generated/artifacts/main.d.ts",
+            "import": "./dist/es/es2018/industries-filebased-dataimport.js",
+            "require": "./dist/es/es2018/industries-filebased-dataimport.js"
+        },
+        "./sfdc": {
+            "types": "./sfdc/index.d.ts",
+            "import": "./sfdc/index.js",
+            "default": "./sfdc/index.js"
+        }
+    },
+    "sfdc": {
+        "namespace": "lightning",
+        "module": "industriesFilebasedDataimportApi"
+    },
+    "contributors": [
+        "mchaba@salesforce.com",
+        "vatsala.jadia@salesforce.com"
+    ],
+    "scripts": {
+        "build": "yarn build:services",
+        "build:raml": "luvio generate src/raml/luvio.raml src/generated -p '../lds-compiler-plugins'",
+        "build:services": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist sfdc src/generated",
+        "release:core": "yarn build && ../core-build/scripts/core.js --name=lds-adapters-industries-filebased-dataimport",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-adapters-industries-filebased-dataimport",
+        "test:unit": "jest"
+    },
+    "dependencies": {
+        "@salesforce/lds-bindings": "^0.1.0-dev1"
+    },
+    "devDependencies": {
+        "@salesforce/lds-compiler-plugins": "^0.1.0-dev1",
+        "@salesforce/lds-karma": "^0.1.0-dev1"
+    },
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "{projectRoot}/dist",
+                    "{projectRoot}/sfdc"
+                ]
+            },
+            "build:raml": {
+                "outputs": [
+                    "{projectRoot}/src/generated"
+                ]
+            }
+        }
+    },
+    "volta": {
+        "extends": "../../package.json"
+    }
+}

package/sfdc/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/es/es2018/types/src/generated/artifacts/sfdc';