@salesforce/lds-adapters-cms-authoring 1.100.1

package/dist/types/src/generated/types/AbstractManagedContentSearchResultRepresentation.d.ts

@@ -0,0 +1,49 @@
+import { ManagedContentUserSummaryRepresentation as ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation } from './ManagedContentUserSummaryRepresentation';
+import { ManagedContentFolderSummaryRepresentation as ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation } from './ManagedContentFolderSummaryRepresentation';
+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 = "ac9c999adfb196593025311013418018";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: AbstractManagedContentSearchResultRepresentation, existing: AbstractManagedContentSearchResultRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): AbstractManagedContentSearchResultRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: AbstractManagedContentSearchResultRepresentationNormalized, incoming: AbstractManagedContentSearchResultRepresentationNormalized): boolean;
+export declare function deepFreeze(input: AbstractManagedContentSearchResultRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: AbstractManagedContentSearchResultRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A keyword-based search result for a Managed Content Variant or Folder.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AbstractManagedContentSearchResultRepresentationNormalized {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The time the managed content variant or folder was created. */
+    createdDate: string;
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation;
+    /** The ID of the managed content variant or folder. */
+    id: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    /** The last time the managed content variant or folder has been modified. */
+    lastModifiedDate: string;
+    /** The content space of the managed content. */
+    managedContentSpaceId: string;
+    /** The class name of this search result; may be used as a discriminator. */
+    type: string;
+}
+/**
+ * A keyword-based search result for a Managed Content Variant or Folder.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface AbstractManagedContentSearchResultRepresentation {
+    createdBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    createdDate: string;
+    folder: ManagedContentFolderSummaryRepresentation_ManagedContentFolderSummaryRepresentation;
+    id: string;
+    lastModifiedBy: ManagedContentUserSummaryRepresentation_ManagedContentUserSummaryRepresentation;
+    lastModifiedDate: string;
+    managedContentSpaceId: string;
+    type: string;
+}

package/dist/types/src/generated/types/CMSChannelRepresentation.d.ts

@@ -0,0 +1,47 @@
+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 = "e77ab0118125481a17a62f2fa9fb890f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: CMSChannelRepresentation, existing: CMSChannelRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): CMSChannelRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: CMSChannelRepresentationNormalized, incoming: CMSChannelRepresentationNormalized): boolean;
+export declare function deepFreeze(input: CMSChannelRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: CMSChannelRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Details of a Managed Content Channel
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CMSChannelRepresentationNormalized {
+    /** Id of the Managed Content Channel */
+    channelId: string;
+    /** Name of the Managed Content Channel */
+    channelName: string;
+    /** Type of Managed Content Channel */
+    channelType: string;
+    /** Domain assigned to the channel. */
+    domain: string;
+    /** Name of the domain assigned to the channel. */
+    domainName: string;
+    /** Enablement of Text Search of Channel's Contents */
+    isChannelSearchable: boolean;
+    /** If the channel domain is editable. */
+    isDomainLocked: boolean;
+}
+/**
+ * Details of a Managed Content Channel
+ *
+ * Keys:
+ *    (none)
+ */
+export interface CMSChannelRepresentation {
+    channelId: string;
+    channelName: string;
+    channelType: string;
+    domain: string;
+    domainName: string;
+    isChannelSearchable: boolean;
+    isDomainLocked: boolean;
+}

package/dist/types/src/generated/types/MCDeliveryV2VariantCollectionRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { MCDeliveryV2VariantRepresentation as MCDeliveryV2VariantRepresentation_MCDeliveryV2VariantRepresentation } from './MCDeliveryV2VariantRepresentation';
+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 = "146cb4d6725310adf034ab404389a8fe";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCDeliveryV2VariantCollectionRepresentation, existing: MCDeliveryV2VariantCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCDeliveryV2VariantCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCDeliveryV2VariantCollectionRepresentationNormalized, incoming: MCDeliveryV2VariantCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCDeliveryV2VariantCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCDeliveryV2VariantCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The collection representing the list of managed content variant information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantCollectionRepresentationNormalized {
+    /** List of all variants */
+    variants: Array<MCDeliveryV2VariantRepresentation_MCDeliveryV2VariantRepresentation>;
+}
+/**
+ * The collection representing the list of managed content variant information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantCollectionRepresentation {
+    variants: Array<MCDeliveryV2VariantRepresentation_MCDeliveryV2VariantRepresentation>;
+}

package/dist/types/src/generated/types/MCDeliveryV2VariantInputRepresentation.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 = "df20e473027ac5f214e9c9e6dbbaf745";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCDeliveryV2VariantInputRepresentation, existing: MCDeliveryV2VariantInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCDeliveryV2VariantInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCDeliveryV2VariantInputRepresentationNormalized, incoming: MCDeliveryV2VariantInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCDeliveryV2VariantInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCDeliveryV2VariantInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to get variants by content ids and variant key
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantInputRepresentationNormalized {
+    /** List of contentIds to filter variants */
+    contentIds: Array<string>;
+    /** Variant Key to filter variants */
+    variantKey: string;
+}
+/**
+ * Input representation to get variants by content ids and variant key
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantInputRepresentation {
+    contentIds: Array<string>;
+    variantKey: string;
+}

package/dist/types/src/generated/types/MCDeliveryV2VariantRepresentation.d.ts

@@ -0,0 +1,53 @@
+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 = "429fac81596061cb8e65ecb4c2539c0d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCDeliveryV2VariantRepresentation, existing: MCDeliveryV2VariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCDeliveryV2VariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCDeliveryV2VariantRepresentationNormalized, incoming: MCDeliveryV2VariantRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCDeliveryV2VariantRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCDeliveryV2VariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The output representation of a managed content variant detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantRepresentationNormalized {
+    /** Content Key of the content */
+    contentKey: string;
+    /** Content type of the content */
+    contentType: string;
+    /** Language of the variant */
+    language: string;
+    /** Last updated by (user id) of the variant */
+    lastUpdatedBy: string;
+    /** Id of the Managed Content */
+    managedContentId: string;
+    /** Published Date of the variant */
+    publishedDate: string;
+    /** Title of the variant */
+    title: string;
+    /** UrlName of the variant */
+    urlName: string;
+    /** Variant Key of the variant */
+    variantKey: string;
+}
+/**
+ * The output representation of a managed content variant detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCDeliveryV2VariantRepresentation {
+    contentKey: string;
+    contentType: string;
+    language: string;
+    lastUpdatedBy: string;
+    managedContentId: string;
+    publishedDate: string;
+    title: string;
+    urlName: string;
+    variantKey: string;
+}

package/dist/types/src/generated/types/MCSiteContentCollectionRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { MCSiteContentRepresentation as MCSiteContentRepresentation_MCSiteContentRepresentation } from './MCSiteContentRepresentation';
+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 = "ee3e857aefed96df2f66e7a70b1d83e2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteContentCollectionRepresentation, existing: MCSiteContentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteContentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteContentCollectionRepresentationNormalized, incoming: MCSiteContentCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteContentCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteContentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The collection representing the list of managed content detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteContentCollectionRepresentationNormalized {
+    /** List of all contents delivered to a site */
+    contents: Array<MCSiteContentRepresentation_MCSiteContentRepresentation>;
+}
+/**
+ * The collection representing the list of managed content detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteContentCollectionRepresentation {
+    contents: Array<MCSiteContentRepresentation_MCSiteContentRepresentation>;
+}

package/dist/types/src/generated/types/MCSiteContentRepresentation.d.ts

@@ -0,0 +1,46 @@
+import { ManagedContentChildRepresentation as ManagedContentChildRepresentation_ManagedContentChildRepresentation } from './ManagedContentChildRepresentation';
+import { MCSiteVariantRepresentation as MCSiteVariantRepresentation_MCSiteVariantRepresentation } from './MCSiteVariantRepresentation';
+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 = "e6075cf4afe12349242c3d4e8f0c07e8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteContentRepresentation, existing: MCSiteContentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteContentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteContentRepresentationNormalized, incoming: MCSiteContentRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteContentRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteContentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The output representation of a managed content detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteContentRepresentationNormalized {
+    /** List of all immediate children of this content */
+    children: Array<ManagedContentChildRepresentation_ManagedContentChildRepresentation>;
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** Type of a Managed Content */
+    contentType: string;
+    /** Id of a Managed Content */
+    managedContentId: string;
+    /** Parent's Content key */
+    parentContentKey: string;
+    /** List of variants of this content delivered */
+    variants: Array<MCSiteVariantRepresentation_MCSiteVariantRepresentation>;
+}
+/**
+ * The output representation of a managed content detailed information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteContentRepresentation {
+    children: Array<ManagedContentChildRepresentation_ManagedContentChildRepresentation>;
+    contentKey: string;
+    contentType: string;
+    managedContentId: string;
+    parentContentKey: string;
+    variants: Array<MCSiteVariantRepresentation_MCSiteVariantRepresentation>;
+}

package/dist/types/src/generated/types/MCSiteDeliveryByContentKeysInputRepresentation.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 = "e7ccb4e2fbf9b769a38846a77acc9ad3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteDeliveryByContentKeysInputRepresentation, existing: MCSiteDeliveryByContentKeysInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteDeliveryByContentKeysInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteDeliveryByContentKeysInputRepresentationNormalized, incoming: MCSiteDeliveryByContentKeysInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteDeliveryByContentKeysInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteDeliveryByContentKeysInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to fetch content by content keys
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByContentKeysInputRepresentationNormalized {
+    /** List of Content keys to filter contents */
+    contentKeys: Array<string>;
+    /** Should include immediate children or not */
+    includeChildren: boolean;
+}
+/**
+ * Input representation to fetch content by content keys
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByContentKeysInputRepresentation {
+    contentKeys: Array<string>;
+    includeChildren: boolean;
+}

package/dist/types/src/generated/types/MCSiteDeliveryByContentTypesInputRepresentation.d.ts

@@ -0,0 +1,29 @@
+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 = "d3334102de350e9d3222d7915d965587";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteDeliveryByContentTypesInputRepresentation, existing: MCSiteDeliveryByContentTypesInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteDeliveryByContentTypesInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteDeliveryByContentTypesInputRepresentationNormalized, incoming: MCSiteDeliveryByContentTypesInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteDeliveryByContentTypesInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteDeliveryByContentTypesInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to fetch content by content types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByContentTypesInputRepresentationNormalized {
+    /** List of Content types to filter contents */
+    contentTypes: Array<string>;
+}
+/**
+ * Input representation to fetch content by content types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByContentTypesInputRepresentation {
+    contentTypes: Array<string>;
+}

package/dist/types/src/generated/types/MCSiteDeliveryByNodesInputRepresentation.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 = "36bcd9909b16457135f6dd9e440043a5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteDeliveryByNodesInputRepresentation, existing: MCSiteDeliveryByNodesInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteDeliveryByNodesInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteDeliveryByNodesInputRepresentationNormalized, incoming: MCSiteDeliveryByNodesInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteDeliveryByNodesInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteDeliveryByNodesInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Input representation to fetch content by content types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByNodesInputRepresentationNormalized {
+    /** content key for a content to fetch nodes */
+    contentKey: string;
+    /** List of node Ids to filter from content */
+    nodeIds: Array<string>;
+}
+/**
+ * Input representation to fetch content by content types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteDeliveryByNodesInputRepresentation {
+    contentKey: string;
+    nodeIds: Array<string>;
+}

package/dist/types/src/generated/types/MCSiteNodeCollectionRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { MCSiteNodeRepresentation as MCSiteNodeRepresentation_MCSiteNodeRepresentation } from './MCSiteNodeRepresentation';
+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 = "52631d769aa4e4675f07c9ddd65737d5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteNodeCollectionRepresentation, existing: MCSiteNodeCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteNodeCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteNodeCollectionRepresentationNormalized, incoming: MCSiteNodeCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteNodeCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteNodeCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * A list of node representations of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteNodeCollectionRepresentationNormalized {
+    /** List of nodes */
+    nodes: Array<MCSiteNodeRepresentation_MCSiteNodeRepresentation>;
+}
+/**
+ * A list of node representations of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteNodeCollectionRepresentation {
+    nodes: Array<MCSiteNodeRepresentation_MCSiteNodeRepresentation>;
+}

package/dist/types/src/generated/types/MCSiteNodeRepresentation.d.ts

@@ -0,0 +1,45 @@
+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 = "3f895a0b6fa5cfb00c81b396a0e83a9e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteNodeRepresentation, existing: MCSiteNodeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteNodeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteNodeRepresentationNormalized, incoming: MCSiteNodeRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteNodeRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteNodeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The node representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteNodeRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** last modified by user of variant */
+    lastModifiedBy: string;
+    /** Map of variant key to node body */
+    nodes: {
+        [key: string]: string;
+    };
+    /** published date of variant */
+    publishDate: string;
+    /** variant key of a variant */
+    variantKey: string;
+}
+/**
+ * The node representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteNodeRepresentation {
+    contentKey: string;
+    lastModifiedBy: string;
+    nodes: {
+        [key: string]: string;
+    };
+    publishDate: string;
+    variantKey: string;
+}

package/dist/types/src/generated/types/MCSiteVariantRepresentation.d.ts

@@ -0,0 +1,47 @@
+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 = "aec62bf8c3772de0c308fedbb06b009c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MCSiteVariantRepresentation, existing: MCSiteVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MCSiteVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MCSiteVariantRepresentationNormalized, incoming: MCSiteVariantRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MCSiteVariantRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MCSiteVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * The variant representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteVariantRepresentationNormalized {
+    /** body of the variant delivered to a site */
+    body: string;
+    /** language of the variant delivered to a site */
+    language: string;
+    /** Last updated by user id of the variant delivered to a site */
+    lastUpdatedBy: string;
+    /** published date of the variant delivered to a site */
+    publishedDate: string;
+    /** title of the variant delivered to a site */
+    title: string;
+    /** urlname/slug of the variant delivered to a site */
+    urlName: string;
+    /** Variant key of the variant delivered to a site */
+    variantKey: string;
+}
+/**
+ * The variant representation of a content
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MCSiteVariantRepresentation {
+    body: string;
+    language: string;
+    lastUpdatedBy: string;
+    publishedDate: string;
+    title: string;
+    urlName: string;
+    variantKey: string;
+}

package/dist/types/src/generated/types/MContentBodyRepresentation.d.ts

@@ -0,0 +1,33 @@
+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 = "c1bd6a5b57f660fa8e662df799b6a53d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentBodyRepresentation, existing: MContentBodyRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentBodyRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentBodyRepresentationNormalized, incoming: MContentBodyRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentBodyRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentBodyRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentBodyRepresentationNormalized {
+    /** Content Body. */
+    body: {
+        [key: string]: {};
+    };
+}
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentBodyRepresentation {
+    body: {
+        [key: string]: {};
+    };
+}

package/dist/types/src/generated/types/MContentCollectionMetadataRepresentation.d.ts

@@ -0,0 +1,39 @@
+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 = "d499d07717d35fdeaf42293ba189a2cf";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentCollectionMetadataRepresentation, existing: MContentCollectionMetadataRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentCollectionMetadataRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentCollectionMetadataRepresentationNormalized, incoming: MContentCollectionMetadataRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentCollectionMetadataRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentCollectionMetadataRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionMetadataRepresentationNormalized {
+    /** Decription of the collection schema. */
+    description: string;
+    /** Schema of the collection type. */
+    schema: {
+        [key: string]: {};
+    };
+    /** Title of the collection schema. */
+    title: string;
+}
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionMetadataRepresentation {
+    description: string;
+    schema: {
+        [key: string]: {};
+    };
+    title: string;
+}

package/dist/types/src/generated/types/MContentCollectionRepresentation.d.ts

@@ -0,0 +1,51 @@
+import { MContentDetailRepresentation as MContentDetailRepresentation_MContentDetailRepresentation } from './MContentDetailRepresentation';
+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 = "753b121c32c64298981f6cc7467c5952";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: MContentCollectionRepresentation, existing: MContentCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): MContentCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: MContentCollectionRepresentationNormalized, incoming: MContentCollectionRepresentationNormalized): boolean;
+export declare function deepFreeze(input: MContentCollectionRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: MContentCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionRepresentationNormalized {
+    /** The content key */
+    contentKey: string;
+    /** URL to the current page of collection details. The default is 25 managed content versions per page. */
+    currentPageUrl: string;
+    /** Decription of the collection. */
+    description: string;
+    /** Managed content versions for this page. */
+    items: Array<MContentDetailRepresentation_MContentDetailRepresentation>;
+    /** URL to the next page of managed content versions, The default is 25 managed content versions per page. */
+    nextPageUrl: string;
+    /** Title of the collection. */
+    title: string;
+    /** Total number of versions across all pages. */
+    total: number;
+    /** Type of the collection. */
+    type: string;
+}
+/**
+ * Collection details.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface MContentCollectionRepresentation {
+    contentKey: string;
+    currentPageUrl: string;
+    description: string;
+    items: Array<MContentDetailRepresentation_MContentDetailRepresentation>;
+    nextPageUrl: string;
+    title: string;
+    total: number;
+    type: string;
+}