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

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

@@ -0,0 +1,39 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+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 = 100;
+export declare const VERSION = "c297f5edbe1b51eadd89e68f176520ba";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByCollectionRepresentation, existing: ManagedContentReferencedByCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentReferencedByCollectionRepresentationNormalized, incoming: ManagedContentReferencedByCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of rof referencing contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByCollectionRepresentationNormalized {
+    /** URL to the current page of managed content references. The default is 25 managed content references per page. */
+    currentPageUrl: string;
+    /** URL to the next page of managed content references, The default is 25 managed content references per page. */
+    nextPageUrl: string | null;
+    /** Managed content referenceBy for this page. */
+    referencedBy: Array<AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation>;
+    /** Total number of referencedBy contents across all pages. */
+    total: number;
+}
+/**
+ * Collection of rof referencing contents
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByCollectionRepresentation {
+    currentPageUrl: string;
+    nextPageUrl: string | null;
+    referencedBy: Array<AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation>;
+    total: number;
+}

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

@@ -0,0 +1,37 @@
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "3306df3b2175592bfe07c027237f2b25";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorItemRepresentation, existing: ManagedContentReferencedByContributorItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorItemRepresentationNormalized, incoming: ManagedContentReferencedByContributorItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the contributor item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorItemRepresentationNormalized {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date when the reference from this contributor item to the managed content was created. */
+    createdDate: string;
+    /** Id of the contributor item */
+    id: string;
+    /** Reference type of the contributor item. */
+    referenceType: string;
+}
+/**
+ * Representation of the contributor item.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    id: string;
+    referenceType: string;
+}

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

@@ -0,0 +1,35 @@
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "0c8b8d4551ce47a050dc2f0995be9bdd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorRepresentation, existing: ManagedContentReferencedByContributorRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorRepresentationNormalized, incoming: ManagedContentReferencedByContributorRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorRepresentationNormalized extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date reference created */
+    createdDate: string;
+    /** Reference type of the contributor */
+    referenceType: string;
+}
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorRepresentation extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    referenceType: string;
+}

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

@@ -0,0 +1,30 @@
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+import { ManagedContentReferencedByContributorItemRepresentation as ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation } from './ManagedContentReferencedByContributorItemRepresentation';
+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 = "f138de9d74ceb518fdccbf217e290c43";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByContributorWithContributorItemsRepresentation, existing: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized, incoming: ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByContributorWithContributorItemsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the contributor with contributor items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorWithContributorItemsRepresentationNormalized extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    /** List of contributor items */
+    contributorItems: Array<ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation>;
+}
+/**
+ * Representation of the contributor with contributor items
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByContributorWithContributorItemsRepresentation extends AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation {
+    contributorItems: Array<ManagedContentReferencedByContributorItemRepresentation_ManagedContentReferencedByContributorItemRepresentation>;
+}

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

@@ -0,0 +1,26 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+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 = "f36c3004a806aefeb01489b4615de4cd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByItemRepresentation, existing: ManagedContentReferencedByItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByItemRepresentationNormalized, incoming: ManagedContentReferencedByItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByItemRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+}
+/**
+ * Representation of the contributor
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByItemRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+}

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

@@ -0,0 +1,32 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+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 = "fcad92443d7f8b4d993415ad501ca358";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByRecordRepresentation, existing: ManagedContentReferencedByRecordRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByRecordRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByRecordRepresentationNormalized, incoming: ManagedContentReferencedByRecordRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByRecordRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the referencing entity
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByRecordRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** Date when this reference was created. */
+    createdDate: string;
+}
+/**
+ * Representation of the referencing entity
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByRecordRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+}

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

@@ -0,0 +1,41 @@
+import { AbstractManagedContentReferencedByItemRepresentation as AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation } from './AbstractManagedContentReferencedByItemRepresentation';
+import { AbstractManagedContentReferencedByContributorRepresentation as AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation } from './AbstractManagedContentReferencedByContributorRepresentation';
+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 = "943d9220966cf4b28e1679899f486ccc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentReferencedByVariantRepresentation, existing: ManagedContentReferencedByVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentReferencedByVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentReferencedByVariantRepresentationNormalized, incoming: ManagedContentReferencedByVariantRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentReferencedByVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation for the managed content variant referencing managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByVariantRepresentationNormalized extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    /** Information about a managed content workspace */
+    contentSpace?: {
+        /** Managed Content Space Id */
+        id: string;
+        /** Name of the workspace */
+        name: string | null;
+    };
+    /** Contributor list */
+    contributors?: Array<AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation>;
+}
+/**
+ * Representation for the managed content variant referencing managed content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentReferencedByVariantRepresentation extends AbstractManagedContentReferencedByItemRepresentation_AbstractManagedContentReferencedByItemRepresentation {
+    contentSpace?: {
+        id: string;
+        name: string | null;
+    };
+    contributors?: Array<AbstractManagedContentReferencedByContributorRepresentation_AbstractManagedContentReferencedByContributorRepresentation>;
+}

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

@@ -0,0 +1,49 @@
+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 = 1000;
+export declare const VERSION = "98edee4f058ced93570a7b0ce2293672";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentRenditionRepresentation, existing: ManagedContentRenditionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentRenditionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentRenditionRepresentationNormalized, incoming: ManagedContentRenditionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentRenditionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a rendition of CMS content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRenditionRepresentationNormalized {
+    /** Globally unique identifier of a managed content */
+    contentKey: string;
+    /** The language of the managed content. */
+    language: string;
+    /** Id of the managed content. */
+    managedContentId: string;
+    /** Body containing rendition of content */
+    renditionBody: {
+        [key: string]: unknown;
+    };
+    /** Schema of rendition */
+    renditionSchema: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Information about a rendition of CMS content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRenditionRepresentation {
+    contentKey: string;
+    language: string;
+    managedContentId: string;
+    renditionBody: {
+        [key: string]: unknown;
+    };
+    renditionSchema: {
+        [key: string]: unknown;
+    };
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentRepresentation.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 = "19555bba992740d3c21f7a9d093ce989";
+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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The output representation of a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** Content type of a Managed Content */
+    contentType: string;
+}
+/**
+ * The output representation of a managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentRepresentation {
+    contentKey: string;
+    contentType: string;
+}

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

@@ -0,0 +1,52 @@
+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 = "83004bae63e4a7255e482252e03afc49";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentScheduleInputRepresentation, existing: ManagedContentScheduleInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentScheduleInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentScheduleInputRepresentationNormalized, incoming: ManagedContentScheduleInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentScheduleInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input required for creating a scheduled deployment in 232
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentScheduleInputRepresentationNormalized {
+    /** Action can be Publish/Unpublish for deployment */
+    action: string;
+    /** Authoring managed content space id where the deployment will be scheduled */
+    contextContentSpaceId: string;
+    /** Name of the deployment */
+    description: string;
+    /** Expiry date of the schedule, used with publish action to auto-unpublish */
+    expireDate?: string;
+    /** PublishContentReference will help publish the reference item */
+    publishContentReference?: boolean;
+    /** For publish/unpublish we need to set the refVariantIds */
+    refVariantIds: Array<string>;
+    /** Setting the schedule date for the deployment */
+    scheduleDate: string;
+    /** For publish/unpublish we need to set the variantIds */
+    variantIds: Array<string>;
+    /** For unpublish we need to set the versionIds */
+    versionIds?: Array<string>;
+}
+/**
+ * Input required for creating a scheduled deployment in 232
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentScheduleInputRepresentation {
+    action: string;
+    contextContentSpaceId: string;
+    description: string;
+    expireDate?: string;
+    publishContentReference?: boolean;
+    refVariantIds: Array<string>;
+    scheduleDate: string;
+    variantIds: Array<string>;
+    versionIds?: Array<string>;
+}

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

@@ -0,0 +1,38 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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,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 = "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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultContentTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/ManagedContentSearchResultItemsCollectionRepresentation.d.ts

@@ -0,0 +1,39 @@
+import { AbstractManagedContentSearchResultRepresentation as AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation } from './AbstractManagedContentSearchResultRepresentation';
+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 = 100;
+export declare const VERSION = "bbcdc04e5d094f6f8048bc2863d86527";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSearchResultItemsCollectionRepresentation, existing: ManagedContentSearchResultItemsCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSearchResultItemsCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSearchResultItemsCollectionRepresentationNormalized, incoming: ManagedContentSearchResultItemsCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultItemsCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * A container of paginated CMS keyword-based search result variant and folder items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultItemsCollectionRepresentationNormalized {
+    /** The total count of search results. */
+    count: number;
+    /** The URI for the current page of search results. */
+    currentPageUri: string;
+    /** A list of search result items. */
+    items: Array<AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation>;
+    /** The URI for the next page of search results. */
+    nextPageUri: string;
+}
+/**
+ * A container of paginated CMS keyword-based search result variant and folder items plus a short search result summary
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSearchResultItemsCollectionRepresentation {
+    count: number;
+    currentPageUri: string;
+    items: Array<AbstractManagedContentSearchResultRepresentation_AbstractManagedContentSearchResultRepresentation>;
+    nextPageUri: string;
+}

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

@@ -0,0 +1,44 @@
+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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } 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 const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * 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/ManagedContentSingleItemDocumentRepresentation.d.ts

@@ -0,0 +1,88 @@
+import { ManagedContentSpaceSummaryRepresentation as ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation } from './ManagedContentSpaceSummaryRepresentation';
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+import { ManagedContentFolderSummaryRepresentation as ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation } from './ManagedContentFolderSummaryRepresentation';
+import { ManagedContentVariantStatusRepresentation as ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation } from './ManagedContentVariantStatusRepresentation';
+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 = 100;
+export declare const VERSION = "3a5747378dc29ae71f5d09b77bed28f9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSingleItemDocumentRepresentation, existing: ManagedContentSingleItemDocumentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSingleItemDocumentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSingleItemDocumentRepresentationNormalized, incoming: ManagedContentSingleItemDocumentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSingleItemDocumentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content in authoring space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSingleItemDocumentRepresentationNormalized {
+    /** The api name of the managed content. */
+    apiName?: string | null;
+    /** Body contains fields defined in the managed content type schema of this managed content. */
+    contentBody: {
+        [key: string]: unknown;
+    };
+    /** Globally unique identifier of a managed content and doesn't change when managed content is moved between production and sandbox environments. */
+    contentKey: string;
+    contentSpace: ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The created date of the managed content. */
+    createdDate: string;
+    /** The content folder of the managed content. */
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation | null;
+    /** Is managed content variant published to any channel. */
+    isPublished: boolean;
+    /** The language of the managed content. */
+    language: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The last time the managed content has been modified. */
+    lastModifiedDate: string;
+    /** Id of the managed content in authoring space. */
+    managedContentId: string;
+    /** The managed content variant in the authoring space. */
+    managedContentVariantId: string;
+    /** Version id of the managed content version. */
+    managedContentVersionId: string;
+    /** The status of the managed content variant. */
+    status?: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation | null;
+    /** The title of the managed content. */
+    title: string;
+    /** The content url name of the managed content. */
+    urlName: string;
+    /** The version number of the managed content. */
+    versionNumber: string | null;
+}
+/**
+ * Information about a managed content in authoring space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSingleItemDocumentRepresentation {
+    apiName?: string | null;
+    contentBody: {
+        [key: string]: unknown;
+    };
+    contentKey: string;
+    contentSpace: ManagedContentSpaceSummaryRepresentation_ManagedContentSpaceSummaryRepresentation;
+    contentType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation | null;
+    isPublished: boolean;
+    language: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    lastModifiedDate: string;
+    managedContentId: string;
+    managedContentVariantId: string;
+    managedContentVersionId: string;
+    status?: ManagedContentVariantStatusRepresentation_ManagedContentVariantStatusRepresentation | null;
+    title: string;
+    urlName: string;
+    versionNumber: string | null;
+}