@salesforce/lds-adapters-cms-delivery 0.131.0

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

@@ -0,0 +1,65 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: ManagedContentJobRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: ManagedContentJobRequestInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentJobRequestInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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,57 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } 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 function deepFreeze(input: ManagedContentMediaNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * 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;
+}

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

@@ -0,0 +1,51 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "50e43b0c09d181a66ca9d58fbe482ccd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentMediaSourceNodeValueRepresentation, existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentMediaSourceNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentMediaSourceNodeValueRepresentationNormalized, incoming: ManagedContentMediaSourceNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentMediaSourceNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentMediaSourceNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The file name of the media source. */
+    fileName: string;
+    /** Whether media source is uploaded or referenced via external url. */
+    isExternal: boolean;
+    /** The type of media like Image, Video or Document. */
+    mediaType: string;
+    /** The mime type of the media source. */
+    mimeType: string;
+    /** Reference id of the uploaded media source */
+    referenceId: string;
+    /** The API url to the bytes of the media source. */
+    resourceUrl: string;
+    /** The url to the bytes of the media source for unauthenticated users. */
+    unauthenticatedUrl: string;
+    /** The url to the bytes of the source for authenticated users. */
+    url: string;
+}
+/**
+ * Information about a source of a managed content media.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentMediaSourceNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    fileName: string;
+    isExternal: boolean;
+    mediaType: string;
+    mimeType: string;
+    referenceId: string;
+    resourceUrl: string;
+    unauthenticatedUrl: string;
+    url: string;
+}

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

@@ -0,0 +1,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "dfeb8fbbc5b04f5e0c137055a0501268";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeTypeRepresentation, existing: ManagedContentNodeTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeTypeRepresentationNormalized, incoming: ManagedContentNodeTypeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentNodeTypeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentationNormalized {
+    /** The label of the managed content node type. */
+    label: string;
+    /** The developer name of the managed content node type. */
+    name: string;
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeTypeRepresentation {
+    label: string;
+    name: string;
+    nodeType: string;
+}

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

@@ -0,0 +1,35 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentUnionSelection as $64$luvio_engine_FragmentUnionSelection, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare enum DiscriminatorValues {
+    Date = "Date",
+    Text = "Text"
+}
+export declare const VERSION = "f459a0803edcf8950c25232fba362a00";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentNodeValueRepresentation, existing: ManagedContentNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentNodeValueRepresentationNormalized;
+export declare const selectChildren: () => $64$luvio_engine_FragmentUnionSelection;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentNodeValueRepresentationNormalized, incoming: ManagedContentNodeValueRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentNodeValueRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare const discriminatorIngest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentationNormalized {
+    /** The type of the managed content node. */
+    nodeType: string;
+}
+/**
+ * Information about a managed content node.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentNodeValueRepresentation {
+    nodeType: string;
+}

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

@@ -0,0 +1,35 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "715cd9b052fdb114a02bd57de6849547";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentRepresentation, existing: ManagedContentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentRepresentationNormalized, incoming: ManagedContentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentationNormalized {
+    /** Content key of the Managed Content. */
+    contentKey: string;
+    /** Response record Id */
+    id: string;
+    /** Id of the published managed content version, or null if there isn't one */
+    publishedVersionId: string;
+}
+/**
+ * Information about a managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentation {
+    contentKey: string;
+    id: string;
+    publishedVersionId: string;
+}

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

@@ -0,0 +1,39 @@
+import { ManagedContentSearchResultRepresentation as ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation } from './ManagedContentSearchResultRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "572c8571162c9b4e876a5807918f62dc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultCollectionRepresentation, existing: ManagedContentSearchResultCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultCollectionRepresentationNormalized, incoming: ManagedContentSearchResultCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A container of paginated cms keyword-based search result items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultCollectionRepresentationNormalized {
+    /** total search result item count */
+    count: number;
+    /** search result URI */
+    currentPageUri: string;
+    /** an array of search result items */
+    items: Array<ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation>;
+    /** next search result URI */
+    nextPageUri: string;
+}
+/**
+ * A container of paginated cms keyword-based search result items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultCollectionRepresentation {
+    count: number;
+    currentPageUri: string;
+    items: Array<ManagedContentSearchResultRepresentation_ManagedContentSearchResultRepresentation>;
+    nextPageUri: string;
+}

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

@@ -0,0 +1,32 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "5f6b2264633c914b484d448513feaa38";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultContentTypeRepresentation, existing: ManagedContentSearchResultContentTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultContentTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultContentTypeRepresentationNormalized, incoming: ManagedContentSearchResultContentTypeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultContentTypeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultContentTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result item's content type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultContentTypeRepresentationNormalized {
+    /** managed content type developer name */
+    developerName: string;
+    /** managed content type label */
+    label: string;
+}
+/**
+ * A keyword-based search result item's content type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultContentTypeRepresentation {
+    developerName: string;
+    label: string;
+}

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

@@ -0,0 +1,45 @@
+import { ManagedContentSearchResultContentTypeRepresentation as ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation } from './ManagedContentSearchResultContentTypeRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "ce64c4bd0832308e5da3e1f327760f21";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultRepresentation, existing: ManagedContentSearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSearchResultRepresentationNormalized, incoming: ManagedContentSearchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSearchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultRepresentationNormalized {
+    /** managed content content key */
+    contentKey: string;
+    /** managed content content type */
+    contentType: ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation;
+    /** managed content id */
+    id: string;
+    /** managed content published date */
+    publishDate: string;
+    /** managed content title */
+    title: string;
+    /** managed content (version) url name */
+    urlName: string;
+}
+/**
+ * A keyword-based search result item
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultRepresentation {
+    contentKey: string;
+    contentType: ManagedContentSearchResultContentTypeRepresentation_ManagedContentSearchResultContentTypeRepresentation;
+    id: string;
+    publishDate: string;
+    title: string;
+    urlName: string;
+}

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

@@ -0,0 +1,44 @@
+import { AbstractMCSFolderRepresentation as AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation } from './AbstractMCSFolderRepresentation';
+import { ManagedContentSpaceFolderRepresentation as ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation } from './ManagedContentSpaceFolderRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "c7f4e18421abf8518331f7134f23db4a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderDetailRepresentation, existing: ManagedContentSpaceFolderDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderDetailRepresentationNormalized, incoming: ManagedContentSpaceFolderDetailRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceFolderDetailRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentationNormalized extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+    /** The User ID of the user who created the folder */
+    createdBy: string;
+    /** The date when the folder was created */
+    createdDate: string;
+    /** The list of the parent folders in the hierarchy - starting from the root upto the direct parent of the folder */
+    folderHierarchy: Array<ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation>;
+    /** The User ID of the user who last modified the folder */
+    lastModifiedBy: string;
+    /** The date when the folder was last modified */
+    lastModifiedDate: string;
+}
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentation extends AbstractMCSFolderRepresentation_AbstractMCSFolderRepresentation {
+    createdBy: string;
+    createdDate: string;
+    folderHierarchy: Array<ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation>;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    id: 'FolderDetail';
+}

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

@@ -0,0 +1,32 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d9cfda700d3293277cc91f1818cbbb3f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionInputRep, existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, incoming: ManagedContentSpaceFolderItemCollectionInputRepNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceFolderItemCollectionInputRep): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRepNormalized {
+    /** ID of the new parent folder to the items should be moved */
+    folderId: string;
+    /** List of IDs of the folder items that need to be moved */
+    folderItems: Array<string>;
+}
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRep {
+    folderId: string;
+    folderItems: Array<string>;
+}

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

@@ -0,0 +1,36 @@
+import { ManagedContentSpaceFolderItemRepresentation as ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation } from './ManagedContentSpaceFolderItemRepresentation';
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "7142324f6c1f6094fb64005991a76983";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionRepresentation, existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, incoming: ManagedContentSpaceFolderItemCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceFolderItemCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentationNormalized {
+    /** The id of the folder */
+    folderId: string;
+    /** The list of the folder items - ManagedContent or ManagedContentSpaceFolder */
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    /** The id of the parent folder */
+    parentFolderId: string;
+}
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentation {
+    folderId: string;
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    parentFolderId: string;
+}

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

@@ -0,0 +1,62 @@
+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, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "e735be99640cccc9c469e9152a3e548a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemRepresentation, existing: ManagedContentSpaceFolderItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemRepresentationNormalized, incoming: ManagedContentSpaceFolderItemRepresentationNormalized): boolean;
+export declare function deepFreeze(input: ManagedContentSpaceFolderItemRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentationNormalized {
+    /** The User ID for the user which created the ManagedContent or ManagedContentSpaceFolder */
+    createdBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was created */
+    createdDate: string;
+    /** Boolean flag to indicate whether this folder has child folders */
+    hasChildFolders: boolean;
+    /** The id of the folder item - ManagedContent or ManagedContentSpaceFolder */
+    id: string;
+    /** Boolean flag to indicate whether this folder item is a folder */
+    isFolder: boolean;
+    /** The User ID for the user which last modified the ManagedContent or ManagedContentSpaceFolder */
+    lastModifiedBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was last modified */
+    lastModifiedDate: string;
+    /** Developer Name for the ManagedContentType if the folder item is ManagedContent */
+    managedContentType: string;
+    /** Latest Managed Content Version Id of the folder item is ManagedContent */
+    managedContentVersionId: string;
+    /** Date when the ManagedContent was last published */
+    publishedDate: string;
+    /** Status of the Managed Content */
+    status: string;
+    /** Title of the ManagedContent/ManagedContentSpaceFolder */
+    title: string;
+}
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentation {
+    createdBy: string;
+    createdDate: string;
+    hasChildFolders: boolean;
+    id: string;
+    isFolder: boolean;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    managedContentType: string;
+    managedContentVersionId: string;
+    publishedDate: string;
+    status: string;
+    title: string;
+}