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

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

@@ -0,0 +1,34 @@
+import { ManagedContentChannelTargetEntitySummaryRepresentation as ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation } from './ManagedContentChannelTargetEntitySummaryRepresentation';
+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 = "15cefa027302e75de834408efb308791";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChannelSummaryRepresentation, existing: ManagedContentChannelSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChannelSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChannelSummaryRepresentationNormalized, incoming: ManagedContentChannelSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentChannelSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelSummaryRepresentationNormalized {
+    /** Name of the managed content channel */
+    name: string;
+    /** Resource Url to fetch complete information of the channel */
+    resourceUrl: string;
+    targetEntity: ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation;
+}
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelSummaryRepresentation {
+    name: string;
+    resourceUrl: string;
+    targetEntity: ManagedContentChannelTargetEntitySummaryRepresentation_ManagedContentChannelTargetEntitySummaryRepresentation;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentChannelTargetEntitySummaryRepresentation.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 = "5822a06dc7aae0f35de02565e442497a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChannelTargetEntitySummaryRepresentation, existing: ManagedContentChannelTargetEntitySummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChannelTargetEntitySummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChannelTargetEntitySummaryRepresentationNormalized, incoming: ManagedContentChannelTargetEntitySummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentChannelTargetEntitySummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelTargetEntitySummaryRepresentationNormalized {
+    /** Id of the target entity associated with the channel */
+    id: string;
+}
+/**
+ * Contextual Information of the channel in managed content delivery api
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChannelTargetEntitySummaryRepresentation {
+    id: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentChildRepresentation.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 = "b06fe159fd96d5fee4317f871d4de5ca";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentChildRepresentation, existing: ManagedContentChildRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentChildRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentChildRepresentationNormalized, incoming: ManagedContentChildRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentChildRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The representation of a child managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChildRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** Type of a Managed Content */
+    contentType: string;
+    /** Id of a Managed Content */
+    managedContentId: string;
+}
+/**
+ * The representation of a child managed content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentChildRepresentation {
+    contentKey: string;
+    contentType: string;
+    managedContentId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentCloneStatusRepresentation.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 = "4aefaff76eec77653cb548f5ef0b18c9";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCloneStatusRepresentation, existing: ManagedContentCloneStatusRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCloneStatusRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentCloneStatusRepresentationNormalized, incoming: ManagedContentCloneStatusRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCloneStatusRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about managed content's clone status.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCloneStatusRepresentationNormalized {
+    /** Localized label for status */
+    label: string;
+    /** Status of managed content clone */
+    status: string;
+}
+/**
+ * Information about managed content's clone status.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCloneStatusRepresentation {
+    label: string;
+    status: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentClonedVariantRepresentation.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 = "f67ea7b44d165e0b476befa391ce6fdb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentClonedVariantRepresentation, existing: ManagedContentClonedVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentClonedVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentClonedVariantRepresentationNormalized, incoming: ManagedContentClonedVariantRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentClonedVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information of successfully cloned variants.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentClonedVariantRepresentationNormalized {
+    /** Language of cloned translated variant. */
+    language: string;
+    /** Managed Content Variant ID of cloned variant. */
+    managedContentVariantId: string;
+    /** Resource URL of cloned managed content variant. */
+    resourceURL: string | null;
+}
+/**
+ * Information of successfully cloned variants.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentClonedVariantRepresentation {
+    language: string;
+    managedContentVariantId: string;
+    resourceURL: string | null;
+}

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

@@ -0,0 +1,66 @@
+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 = 100;
+export declare const VERSION = "04fc59c4443f12c021c76e1603338c85";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentCollectionDetailRepresentation, existing: ManagedContentCollectionDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentCollectionDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentCollectionDetailRepresentationNormalized, incoming: ManagedContentCollectionDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentCollectionDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about collection Items for authoring.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionDetailRepresentationNormalized {
+    /** 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;
+    /** Published Date of the collection. */
+    isPublished: boolean;
+    /** 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;
+    /** Title of the collection. */
+    title: string;
+    /** Total number of items in current collection detail page. */
+    total?: number;
+    /** URL Name of the collection. */
+    urlName: string;
+    /** The version number of the managed content collection. */
+    versionNumber: string;
+}
+/**
+ * Information about collection Items for authoring.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentCollectionDetailRepresentation {
+    collectionKey: string;
+    collectionType: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    currentPageUrl: string;
+    id: string;
+    isPublished: boolean;
+    items: Array<ManagedContentCollectionItemRepresentation_ManagedContentCollectionItemRepresentation>;
+    language: string;
+    nextPageUrl?: string;
+    previousPageUrl?: string;
+    title: string;
+    total?: number;
+    urlName: string;
+    versionNumber: string;
+}

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/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,32 @@
+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;
+}

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

@@ -0,0 +1,29 @@
+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;
+}

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

@@ -0,0 +1,48 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { ManagedContentDeploymentRepresentation as ManagedContentDeploymentRepresentation_ManagedContentDeploymentRepresentation } from './ManagedContentDeploymentRepresentation';
+export declare const TTL = 100;
+export declare const VERSION = "b2c15aa80814ecd854e68bf635879e35";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentCollectionRepresentation, existing: ManagedContentDeploymentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    deployments: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ManagedContentDeploymentCollectionRepresentation, existing: ManagedContentDeploymentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ManagedContentDeploymentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    deployments?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentCollectionRepresentationNormalized, incoming: ManagedContentDeploymentCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * Collection of Deployments
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentCollectionRepresentationNormalized {
+    /** URL to the current page of Manage Content deployment records. */
+    currentPageUrl: string;
+    /** ManagedContentDeployment collection */
+    deployments: Array<$64$luvio_engine_StoreLink>;
+    /** URL to the next page of Manage Content deployment records. */
+    nextPageUrl: string | null;
+    /** URL to the previous page of Managed Content deployment records. */
+    previousPageUrl: string | null;
+}
+/**
+ * Collection of Deployments
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentCollectionRepresentation {
+    currentPageUrl: string;
+    deployments: Array<ManagedContentDeploymentRepresentation_ManagedContentDeploymentRepresentation>;
+    nextPageUrl: string | null;
+    previousPageUrl: string | null;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentDeploymentInputRepresentation.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, 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 = "0f99d9ccf1a20440fa557cc86aea9942";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentInputRepresentation, existing: ManagedContentDeploymentInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentInputRepresentationNormalized, incoming: ManagedContentDeploymentInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputRepresentationNormalized {
+    /** [Optional] The target channel to publish content to. */
+    channelIds?: Array<string>;
+    /** [Optional] The contents to publish. Not valid to have both contentIds and variantIds. */
+    contentIds?: Array<string>;
+    /** The content space to publish content from. */
+    contentSpaceId: string;
+    /** Description for deployment. */
+    description?: string;
+    /** [Optional] Execute all staged deployments. */
+    executeStagedDeployments?: boolean;
+    /** [Optional] Include Content References for deployment. */
+    includeContentReferences?: boolean;
+    /** [Optional] Scheduled date for deployment. */
+    scheduledDate?: string;
+    /** [Optional] The variants to publish. Not valid to have both contentIds and variantIds */
+    variantIds?: Array<string>;
+}
+/**
+ * Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputRepresentation {
+    channelIds?: Array<string>;
+    contentIds?: Array<string>;
+    contentSpaceId: string;
+    description?: string;
+    executeStagedDeployments?: boolean;
+    includeContentReferences?: boolean;
+    scheduledDate?: string;
+    variantIds?: Array<string>;
+}

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

@@ -0,0 +1,28 @@
+import { ManagedContentDeploymentInputRepresentation as ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation } from './ManagedContentDeploymentInputRepresentation';
+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 = "563d3788f6061c3eceebb9d0127e010c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentInputWrapperRepresentation, existing: ManagedContentDeploymentInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentInputWrapperRepresentationNormalized, incoming: ManagedContentDeploymentInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * wrapper for Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputWrapperRepresentationNormalized {
+    DeploymentInput: ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation;
+}
+/**
+ * wrapper for Input required for creating a deployment
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentInputWrapperRepresentation {
+    DeploymentInput: ManagedContentDeploymentInputRepresentation_ManagedContentDeploymentInputRepresentation;
+}

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

@@ -0,0 +1,49 @@
+import { ManagedContentVariantSnapshotSummaryRepresentation as ManagedContentVariantSnapshotSummaryRepresentation_ManagedContentVariantSnapshotSummaryRepresentation } from './ManagedContentVariantSnapshotSummaryRepresentation';
+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 = "f99d45f1e809783023bfd9dbe2fe4a6c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentDeploymentItemRepresentation, existing: ManagedContentDeploymentItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentDeploymentItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentDeploymentItemRepresentationNormalized, incoming: ManagedContentDeploymentItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentDeploymentItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a deploymentItem
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentItemRepresentationNormalized {
+    /** Action for the ITEM */
+    action: string;
+    /** ManagedContentDeployment Entity Id */
+    deploymentId: string;
+    /** ManagedContentDeploymentItem Entity Id */
+    deploymentItemId: string;
+    /** IsTopLevel */
+    isTopLevel: boolean;
+    mcvSnapshotSummary: ManagedContentVariantSnapshotSummaryRepresentation_ManagedContentVariantSnapshotSummaryRepresentation;
+    /** Snapshot Entity Id */
+    snapshotId: string;
+    /** Target Entity Id */
+    targetId: string | null;
+    /** ManagedContentVariantId of DeploymentItem */
+    variantId: string | null;
+}
+/**
+ * Information about a deploymentItem
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentDeploymentItemRepresentation {
+    action: string;
+    deploymentId: string;
+    deploymentItemId: string;
+    isTopLevel: boolean;
+    mcvSnapshotSummary: ManagedContentVariantSnapshotSummaryRepresentation_ManagedContentVariantSnapshotSummaryRepresentation;
+    snapshotId: string;
+    targetId: string | null;
+    variantId: string | null;
+}