@salesforce/lds-adapters-cms-delivery 0.1.0-dev1

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

@@ -0,0 +1,41 @@
+import { ManagedContentCollectionItemTypeSummaryRepresentation as ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation } from './ManagedContentCollectionItemTypeSummaryRepresentation';
+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 = "e48874c125059a35740c268f47c641ff";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemRepresentation, existing: ManagedContentCollectionItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionItemRepresentationNormalized, incoming: ManagedContentCollectionItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemRepresentationNormalized {
+    /** Get the content body of collection item */
+    body: {
+        [key: string]: unknown;
+    };
+    contentType: ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation;
+    /** The unique identifier of collection item. */
+    id: string;
+    /** The name or title for collection item */
+    name: string;
+}
+/**
+ * Compact information about a content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemRepresentation {
+    body: {
+        [key: string]: unknown;
+    };
+    contentType: ManagedContentCollectionItemTypeSummaryRepresentation_ManagedContentCollectionItemTypeSummaryRepresentation;
+    id: string;
+    name: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentCollectionItemTypeSummaryRepresentation.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 = "455d12322ac1725bfd56e37d2fc2a4f0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemTypeSummaryRepresentation, existing: ManagedContentCollectionItemTypeSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemTypeSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionItemTypeSummaryRepresentationNormalized, incoming: ManagedContentCollectionItemTypeSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemTypeSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a collection item type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemTypeSummaryRepresentationNormalized {
+    /** Fully qualified name of collection item type. */
+    fullyQualifiedName: string;
+    /** Name of collection item type. */
+    name: string;
+}
+/**
+ * Information about a collection item type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemTypeSummaryRepresentation {
+    fullyQualifiedName: string;
+    name: string;
+}

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

@@ -0,0 +1,67 @@
+import { ManagedContentDeliveryChannelSummaryRepresentation as ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation } from './ManagedContentDeliveryChannelSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentCollectionItemRepresentation as ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation } from './ManagedContentCollectionItemRepresentation';
+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 TTL = 3600000;
+export declare const VERSION = "b513480693ae9012df7865f2698d2001";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionItemsRepresentation, existing: ManagedContentCollectionItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionItemsRepresentationNormalized, incoming: ManagedContentCollectionItemsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about collection Items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemsRepresentationNormalized {
+    /** The contextual information of the delivery managed content channel */
+    channelSummary: ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation;
+    /** The collection key */
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** URL to the current page of collection authoring records. */
+    currentPageUrl: string;
+    /** The id of the collection */
+    id: string;
+    /** Collection Items for this page. */
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    /** language of the collection. */
+    language: string;
+    /** URL to the next page of collection authoring records. */
+    nextPageUrl?: string;
+    /** URL to the previous page of collection authoring records. */
+    previousPageUrl?: string;
+    /** Published Date of the collection. */
+    publishedDate: string;
+    /** Title of the collection. */
+    title: string;
+    /** Total number of items in current collection detail page. */
+    total?: number;
+    /** URL Name of the collection. */
+    urlName: string;
+}
+/**
+ * Information about collection Items.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionItemsRepresentation {
+    channelSummary: ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation;
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    currentPageUrl: string;
+    id: string;
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    language: string;
+    nextPageUrl?: string;
+    previousPageUrl?: string;
+    publishedDate: string;
+    title: string;
+    total?: number;
+    urlName: string;
+}

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

@@ -0,0 +1,65 @@
+import { ManagedContentDeliveryChannelSummaryRepresentation as ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation } from './ManagedContentDeliveryChannelSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+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 TTL = 3600000;
+export declare const VERSION = "04f084216502225bdb5fe939fc41b883";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionMetadataRepresentation, existing: ManagedContentCollectionMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionMetadataRepresentationNormalized, incoming: ManagedContentCollectionMetadataRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection Metadata.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionMetadataRepresentationNormalized {
+    /** The contextual information of the delivery managed content channel */
+    channelSummary: ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation;
+    /** Globally unique identifier of a collection and doesn't change when collection is moved between production and sandbox environments. */
+    collectionKey: string;
+    /** The basic metadata of the collection */
+    collectionMetadata: {
+        [key: string]: unknown;
+    };
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** Id of the collection. */
+    id: string;
+    /** The language of the collection. */
+    language: string;
+    /** The last time the collection has been published. */
+    publishedDate: string;
+    /** The expanded type metadata of the collection */
+    schema: {
+        [key: string]: unknown;
+    };
+    /** The title of the collection. */
+    title: string;
+    /** The content url name of the collection. */
+    urlName: string;
+}
+/**
+ * Collection Metadata.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionMetadataRepresentation {
+    channelSummary: ManagedContentDeliveryChannelSummaryRepresentation_ManagedContentDeliveryChannelSummaryRepresentation;
+    collectionKey: string;
+    collectionMetadata: {
+        [key: string]: unknown;
+    };
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    id: string;
+    language: string;
+    publishedDate: string;
+    schema: {
+        [key: string]: unknown;
+    };
+    title: string;
+    urlName: string;
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentRepresentation as ManagedContentRepresentation_ManagedContentRepresentation } from './ManagedContentRepresentation';
+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 = "45cefa762cde4d4011ccb1568def82ae";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionRepresentation, existing: ManagedContentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCollectionRepresentationNormalized, incoming: ManagedContentCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The output representation of a list of contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionRepresentationNormalized {
+    /** List of contents */
+    contents: Array<ManagedContentRepresentation_ManagedContentRepresentation>;
+}
+/**
+ * The output representation of a list of contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionRepresentation {
+    contents: Array<ManagedContentRepresentation_ManagedContentRepresentation>;
+}

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

@@ -0,0 +1,33 @@
+import { ManagedContentNodeValueRepresentation as ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation } from './ManagedContentNodeValueRepresentation';
+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 = "b271dacd24edaebd946f545cf6a610c8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDateAndTimeNodeValueRepresentation, existing: ManagedContentDateAndTimeNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDateAndTimeNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDateAndTimeNodeValueRepresentationNormalized, incoming: ManagedContentDateAndTimeNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDateAndTimeNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of datetime type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateAndTimeNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The DateTime value in UTC of the managed content node. */
+    dateTimeValue: string;
+    /** The TimeZone in which DateTime is authored of the managed content node. */
+    timeZone: string;
+}
+/**
+ * Information about a managed content node of datetime type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateAndTimeNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    dateTimeValue: string;
+    timeZone: string;
+    nodeType: 'Date';
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentNodeValueRepresentation as ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation } from './ManagedContentNodeValueRepresentation';
+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 = "e6edcbe8357965ca6c5ceb4e782eaf62";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDateNodeValueRepresentation, existing: ManagedContentDateNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDateNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDateNodeValueRepresentationNormalized, incoming: ManagedContentDateNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDateNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of type date.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The date value of the managed content node. */
+    value: string;
+}
+/**
+ * Information about a managed content node of type date.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDateNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    value: string;
+    nodeType: 'Date';
+}

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

@@ -0,0 +1,43 @@
+import { ManagedContentChannelTargetSummaryRepresentation as ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation } from './ManagedContentChannelTargetSummaryRepresentation';
+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 = "b899e1537e70bbf01d50513be0a67e52";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeliveryChannelSummaryRepresentation, existing: ManagedContentDeliveryChannelSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeliveryChannelSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeliveryChannelSummaryRepresentationNormalized, incoming: ManagedContentDeliveryChannelSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDeliveryChannelSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Summary information of a CMS Delivery Channel
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeliveryChannelSummaryRepresentationNormalized {
+    /** Domain Url of the org */
+    domainUrl: string;
+    /** Id of the Managed Content Channel */
+    id: string;
+    /** Name of the managed content channel */
+    name: string;
+    /** Resource URL for detailed information about the ManagedContentChannel */
+    resourceUrl: string;
+    target?: ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation;
+    /** Type of Managed Content Channel */
+    type: string;
+}
+/**
+ * Summary information of a CMS Delivery Channel
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeliveryChannelSummaryRepresentation {
+    domainUrl: string;
+    id: string;
+    name: string;
+    resourceUrl: string;
+    target?: ManagedContentChannelTargetSummaryRepresentation_ManagedContentChannelTargetSummaryRepresentation;
+    type: string;
+}

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

@@ -0,0 +1,32 @@
+import { ManagedContentDetailRepresentation as ManagedContentDetailRepresentation_ManagedContentDetailRepresentation } from './ManagedContentDetailRepresentation';
+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 = "d2bd3b32e6edf2fb85c366b44e0bab7e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDetailCollectionRepresentation, existing: ManagedContentDetailCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDetailCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDetailCollectionRepresentationNormalized, incoming: ManagedContentDetailCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDetailCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of ManagedContentDetailCollection
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailCollectionRepresentationNormalized {
+    /** Managed Content Details */
+    managedContentRecords: Array<ManagedContentDetailRepresentation_ManagedContentDetailRepresentation>;
+    /** Total count of records */
+    totalItem: number;
+}
+/**
+ * Collection of ManagedContentDetailCollection
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailCollectionRepresentation {
+    managedContentRecords: Array<ManagedContentDetailRepresentation_ManagedContentDetailRepresentation>;
+    totalItem: number;
+}

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

@@ -0,0 +1,37 @@
+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 = "34b00f0dce16a33620ec4e3aa3fd117e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDetailRepresentation, existing: ManagedContentDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDetailRepresentationNormalized, incoming: ManagedContentDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailRepresentationNormalized {
+    /** Content Key */
+    contentKey: string;
+    /** Id of the Managed Content */
+    managedContentId: string;
+    /** Id Managed Content Space */
+    managedContentSpaceId: string;
+    /** Id of the Managed Content Version */
+    managedContentVersionId: string;
+}
+/**
+ * Details of a Managed Content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDetailRepresentation {
+    contentKey: string;
+    managedContentId: string;
+    managedContentSpaceId: string;
+    managedContentVersionId: string;
+}

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

@@ -0,0 +1,28 @@
+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 = "f7f62279f5c067e9748e1efa728a0ee8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentInputRep, existing: ManagedContentInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentInputRepNormalized, incoming: ManagedContentInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRepNormalized {
+    /** The published version id of the managed content. */
+    publishedVersionId: string;
+}
+/**
+ * Input representation for a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentInputRep {
+    publishedVersionId: string;
+}

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

@@ -0,0 +1,64 @@
+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 = "8cb61e48d5546a1c3852fe6644c476de";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobRepresentation, existing: ManagedContentJobRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobRepresentationNormalized, incoming: ManagedContentJobRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRepresentationNormalized {
+    /** The user id who created the managed content  job */
+    createdBy: string;
+    /** The created date of the managed content  job */
+    createdDate: string;
+    /** The URL to get the error content body of a managed content  job */
+    errorBodyUrl: string;
+    /** The id of a managed content job */
+    id: string;
+    /** The URL to get the input content body of a managed content  job */
+    inputBodyUrl: string;
+    /** The type of a managed content job */
+    jobType: string;
+    /** The last user id who has modified the managed content  job */
+    lastModifiedBy: string;
+    /** The last time the managed content job has been modified */
+    lastModifiedDate: string;
+    /** The last status update date of a managed content  job */
+    lastStatusUpdateDate: string;
+    /** The name of a managed content job */
+    name: string;
+    /** The URL to get the output content body of a managed content  job */
+    outputBodyUrl: string;
+    /** The start date of a managed content  job */
+    startDate: string;
+    /** The status of a managed content  job */
+    status: string;
+}
+/**
+ * Information about a managed content import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRepresentation {
+    createdBy: string;
+    createdDate: string;
+    errorBodyUrl: string;
+    id: string;
+    inputBodyUrl: string;
+    jobType: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    lastStatusUpdateDate: string;
+    name: string;
+    outputBodyUrl: string;
+    startDate: string;
+    status: string;
+}

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

@@ -0,0 +1,34 @@
+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 = "0a78bf32e5cc358c522977419f9b8a6c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentJobRequestInputRepresentation, existing: ManagedContentJobRequestInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentJobRequestInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentJobRequestInputRepresentationNormalized, incoming: ManagedContentJobRequestInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for creating a ManagedContent import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRequestInputRepresentationNormalized {
+    /** ContentBody Id of Managed Content Import data */
+    contentBodyId: string;
+    /** Managed Content Space Id */
+    contentSpaceId: string;
+    /** Managed Content Job Name */
+    name: string;
+}
+/**
+ * Input representation for creating a ManagedContent import/export job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentJobRequestInputRepresentation {
+    contentBodyId: string;
+    contentSpaceId: string;
+    name: string;
+}

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

@@ -0,0 +1,56 @@
+import { ManagedContentNodeValueRepresentation as ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation } from './ManagedContentNodeValueRepresentation';
+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 = "af8c456537766cfd5c8c55df42f0abb5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaNodeValueRepresentation, existing: ManagedContentMediaNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaNodeValueRepresentationNormalized, incoming: ManagedContentMediaNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The alternate text for the managed content node. */
+    altText: string;
+    /** The contentKey of managed content being referenced. */
+    contentKey: string;
+    /** The file name of the managed content node. */
+    fileName: string;
+    /** The media type of the managed content node like Image, Video or Document */
+    mediaType: string;
+    /** The mime type of the managed content node. */
+    mimeType: string;
+    /** The resource url of the managed content node. */
+    resourceUrl: string;
+    /** Media thumbnail url. */
+    thumbnailUrl: string;
+    /** The title of the managed content node. */
+    title: string;
+    /** The unauthenticated url of the managed content node. */
+    unauthenticatedUrl: string;
+    /** The url of the managed content node. */
+    url: string;
+}
+/**
+ * Information about a managed content node of media type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    altText: string;
+    contentKey: string;
+    fileName: string;
+    mediaType: string;
+    mimeType: string;
+    resourceUrl: string;
+    thumbnailUrl: string;
+    title: string;
+    unauthenticatedUrl: string;
+    url: string;
+}