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

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

@@ -0,0 +1,80 @@
+import { ManagedContentAssociationsRepresentation as ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation } from './ManagedContentAssociationsRepresentation';
+import { ReferenceRepresentation as ReferenceRepresentation_ReferenceRepresentation } from './ReferenceRepresentation';
+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 = "bef7bebf0b431a15870104277c555841";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionInternalRepresentation, existing: ManagedContentVersionInternalRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionInternalRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionInternalRepresentationNormalized, incoming: ManagedContentVersionInternalRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionInternalRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionInternalRepresentationNormalized {
+    /** The Managed Content Associations, e.g. topic associations, describing how this Managed Content is organized and discoverable */
+    associations: ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation;
+    /** The unique identifer of the managed content in the authoring space. */
+    authoredManagedContentId: string;
+    /** Get the body */
+    body: {
+        [key: string]: {};
+    };
+    /** The content key */
+    contentKey: string;
+    createdByReference: ReferenceRepresentation_ReferenceRepresentation;
+    /** Get the date when the managed content version was created. */
+    createdDate: string;
+    /** Response record Id */
+    id: string;
+    lastUpdatedByReference: ReferenceRepresentation_ReferenceRepresentation;
+    /** Id of the managed content that this is a version of */
+    managedContentId: string;
+    /** Master Language of the managed content in the authoring space. */
+    masterLanguage: string;
+    /** Get the date when managed content version was published. */
+    publishDate: string;
+    /** The status of the managed content version. */
+    status: string;
+    /** Get the title of the managed content version. */
+    title: string;
+    /** The type of the managed content version. */
+    type: string;
+    /** The type label of the managed content version. */
+    typeLabel: string;
+    /** Get the date when the managed content version was updated. */
+    updatedDate: string;
+    /** The url of the managed content version */
+    urlName: string;
+}
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionInternalRepresentation {
+    associations: ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation;
+    authoredManagedContentId: string;
+    body: {
+        [key: string]: {};
+    };
+    contentKey: string;
+    createdByReference: ReferenceRepresentation_ReferenceRepresentation;
+    createdDate: string;
+    id: string;
+    lastUpdatedByReference: ReferenceRepresentation_ReferenceRepresentation;
+    managedContentId: string;
+    masterLanguage: string;
+    publishDate: string;
+    status: string;
+    title: string;
+    type: string;
+    typeLabel: string;
+    updatedDate: string;
+    urlName: string;
+}

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

@@ -0,0 +1,64 @@
+import { ManagedContentAssociationsRepresentation as ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation } from './ManagedContentAssociationsRepresentation';
+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 = "53b3dab3c92d1892aa5825471c442c91";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionRepresentation, existing: ManagedContentVersionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionRepresentationNormalized, incoming: ManagedContentVersionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionRepresentationNormalized {
+    /** The Managed Content Associations, e.g. topic associations, describing how this Managed Content is organized and discoverable */
+    associations: ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation;
+    /** The content key */
+    contentKey: string;
+    /** Get the content nodes */
+    contentNodes: {
+        [key: string]: ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation;
+    };
+    /** The content url name of the managed content version. */
+    contentUrlName: string;
+    /** The language of the managed content version. */
+    language: string;
+    /** The unique identifier of the managed content in the authoring space. */
+    managedContentId: string;
+    /** Get the date when the managed content version was last published. */
+    publishedDate: string;
+    /** Get the title of the managed content version. */
+    title: string;
+    /** The type of the managed content version. */
+    type: string;
+    /** The type label of the managed content type. */
+    typeLabel: string;
+    /** Unauthenticated delivery Url */
+    unauthenticatedUrl: string;
+}
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionRepresentation {
+    associations: ManagedContentAssociationsRepresentation_ManagedContentAssociationsRepresentation;
+    contentKey: string;
+    contentNodes: {
+        [key: string]: ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation;
+    };
+    contentUrlName: string;
+    language: string;
+    managedContentId: string;
+    publishedDate: string;
+    title: string;
+    type: string;
+    typeLabel: string;
+    unauthenticatedUrl: string;
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentVersionSiteNodeRepresentation as ManagedContentVersionSiteNodeRepresentation_ManagedContentVersionSiteNodeRepresentation } from './ManagedContentVersionSiteNodeRepresentation';
+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 = "d006df4f3e96d971e4c3beec92dcffae";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionSiteNodeCollectionRepresentation, existing: ManagedContentVersionSiteNodeCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionSiteNodeCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionSiteNodeCollectionRepresentationNormalized, incoming: ManagedContentVersionSiteNodeCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionSiteNodeCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The managed content version node collection representation of a content for a site
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionSiteNodeCollectionRepresentationNormalized {
+    /** parentId of the node returned */
+    nodes: Array<ManagedContentVersionSiteNodeRepresentation_ManagedContentVersionSiteNodeRepresentation>;
+}
+/**
+ * The managed content version node collection representation of a content for a site
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionSiteNodeCollectionRepresentation {
+    nodes: Array<ManagedContentVersionSiteNodeRepresentation_ManagedContentVersionSiteNodeRepresentation>;
+}

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

@@ -0,0 +1,40 @@
+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 = "fd7060f8bc61898434fe2fca45e864ee";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionSiteNodeRepresentation, existing: ManagedContentVersionSiteNodeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionSiteNodeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionSiteNodeRepresentationNormalized, incoming: ManagedContentVersionSiteNodeRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionSiteNodeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The managed content version node representation of a content for a site
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionSiteNodeRepresentationNormalized {
+    /** Content key of a Managed Content */
+    contentKey: string;
+    /** id of the node returned */
+    id: string;
+    /** Managed Content Version id */
+    managedContentVersionId: string;
+    /** Node body */
+    nodeBody: string;
+    /** parentId of the node returned */
+    parentId: string;
+}
+/**
+ * The managed content version node representation of a content for a site
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionSiteNodeRepresentation {
+    contentKey: string;
+    id: string;
+    managedContentVersionId: string;
+    nodeBody: string;
+    parentId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentVersionV2CollectionInputRepresentation.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 = "154a42838aa87d99adc9f6842d857778";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionV2CollectionInputRepresentation, existing: ManagedContentVersionV2CollectionInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionV2CollectionInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionV2CollectionInputRepresentationNormalized, incoming: ManagedContentVersionV2CollectionInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionV2CollectionInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for collection of managed content version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2CollectionInputRepresentationNormalized {
+    /** List of IDs of the ManagedContentVersion that need to be bulk inserted. */
+    managedContentVersions: Array<{}>;
+}
+/**
+ * Input representation for collection of managed content version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2CollectionInputRepresentation {
+    managedContentVersions: Array<{}>;
+}

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

@@ -0,0 +1,32 @@
+import { ManagedContentVersionV2Representation as ManagedContentVersionV2Representation_ManagedContentVersionV2Representation } from './ManagedContentVersionV2Representation';
+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 = "d540d162663dafc21fd3255af616d9dd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionV2CollectionRepresentation, existing: ManagedContentVersionV2CollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionV2CollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionV2CollectionRepresentationNormalized, incoming: ManagedContentVersionV2CollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionV2CollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of json based managed content versions.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2CollectionRepresentationNormalized {
+    /** Total number of versions across all pages. */
+    total: number;
+    /** Managed content versions for this page. */
+    versions: Array<ManagedContentVersionV2Representation_ManagedContentVersionV2Representation>;
+}
+/**
+ * Collection of json based managed content versions.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2CollectionRepresentation {
+    total: number;
+    versions: Array<ManagedContentVersionV2Representation_ManagedContentVersionV2Representation>;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentVersionV2InputRepresentation.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, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "851d0a1e7d105bf71589739f9b43fb51";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionV2InputRepresentation, existing: ManagedContentVersionV2InputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionV2InputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionV2InputRepresentationNormalized, incoming: ManagedContentVersionV2InputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionV2InputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for a managed content version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2InputRepresentationNormalized {
+    /** The body of the managed content version. */
+    body: {
+        [key: string]: {};
+    };
+    /** Content Key of a managed content id. */
+    contentKey: string;
+    /** The language of the managed content version. */
+    language: string;
+    /** Id of a managed content id. This is only required when creating a new version of an already existing managed content. If this is specified the operation will mean "create a new version of the managed content with id".  */
+    managedContentId: string;
+    /** Content Key of Parent Managed Content */
+    parentIdOrKey: string;
+    /** The title of the managed content version. */
+    title: string;
+    /** The type of the managed content, represents a category of content such as News, Blog or Story. The ManagedContentType.DeveloperName of the active ManagedContentTypeVersion of the ManagedContentVersion. This is always required. */
+    type: string;
+    /** A string that uniquely identifies the content within the org, could be used in e.g. URLs. */
+    urlName: string;
+}
+/**
+ * Input representation for a managed content version
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2InputRepresentation {
+    body: {
+        [key: string]: {};
+    };
+    contentKey: string;
+    language: string;
+    managedContentId: string;
+    parentIdOrKey: string;
+    title: string;
+    type: string;
+    urlName: string;
+}

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

@@ -0,0 +1,74 @@
+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 = "ef3f2a0078edd3fe36892f61a6ad3582";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionV2Representation, existing: ManagedContentVersionV2RepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionV2RepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVersionV2RepresentationNormalized, incoming: ManagedContentVersionV2RepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionV2Representation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2RepresentationNormalized {
+    /** Get body of the managed content version. */
+    body: {
+        [key: string]: {};
+    };
+    /** Content Key of the managed content. */
+    contentKey: string;
+    /** The user id who created the managed content  version */
+    createdBy: string;
+    /** The created date of the managed content  version */
+    createdDate: string;
+    /** The unique identifier of the managed content version in the authoring space. */
+    id: string;
+    /** The master language of the managed content version. */
+    language: string;
+    /** The last user id who has modified the managed content  version */
+    lastModifiedBy: string;
+    /** The last time the managed content version has been modified */
+    lastModifiedDate: string;
+    /** The unique identifier of the managed content in the authoring space. */
+    managedContentId: string;
+    /** Parent ManagedContent Id of the managed content version. */
+    parentId: string;
+    /** The language of the managed content version. */
+    renditionLanguage: string;
+    /** Get status of the managed content version. */
+    status: string;
+    /** Get the title of the managed content version. */
+    title: string;
+    /** The type of the managed content version. */
+    type: string;
+    /** The content url name of the managed content version. */
+    urlName: string;
+}
+/**
+ * Information about a managed content version.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionV2Representation {
+    body: {
+        [key: string]: {};
+    };
+    contentKey: string;
+    createdBy: string;
+    createdDate: string;
+    id: string;
+    language: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    managedContentId: string;
+    parentId: string;
+    renditionLanguage: string;
+    status: string;
+    title: string;
+    type: string;
+    urlName: string;
+}

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

@@ -0,0 +1,31 @@
+import { ManagedContentSiteInfoRepresentation as ManagedContentSiteInfoRepresentation_ManagedContentSiteInfoRepresentation } from './ManagedContentSiteInfoRepresentation';
+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 = "90f6dcf643734d3bfe8ac093bc7edbe4";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentWebUrlInfoRepresentation, existing: ManagedContentWebUrlInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentWebUrlInfoRepresentationNormalized, incoming: ManagedContentWebUrlInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of the url information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlInfoRepresentationNormalized {
+    siteInfo?: ManagedContentSiteInfoRepresentation_ManagedContentSiteInfoRepresentation;
+    /** Url for the url alias and domain */
+    url: string;
+}
+/**
+ * Output representation of the url information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlInfoRepresentation {
+    siteInfo?: ManagedContentSiteInfoRepresentation_ManagedContentSiteInfoRepresentation;
+    url: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentWebUrlRedirectInfoInputRepresentation.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 = "ef0ec7216ff4fa0976a346f655be54ee";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentWebUrlRedirectInfoInputRepresentation, existing: ManagedContentWebUrlRedirectInfoInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlRedirectInfoInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentWebUrlRedirectInfoInputRepresentationNormalized, incoming: ManagedContentWebUrlRedirectInfoInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlRedirectInfoInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for updating the WebURL (URL Alias). The body includes either the URL Alias or the External Redirect URL that the user wishes to update, depending on the current state of the Web URL record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlRedirectInfoInputRepresentationNormalized {
+    /** To-be updated URL Alias designated for the content. This is applicable only when the WebURL status is NOT Active */
+    redirectUrl: string;
+}
+/**
+ * Input representation for updating the WebURL (URL Alias). The body includes either the URL Alias or the External Redirect URL that the user wishes to update, depending on the current state of the Web URL record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlRedirectInfoInputRepresentation {
+    redirectUrl: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentWebUrlRedirectInfoOutputRepresentation.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 = "ce283779ed2c2315349edf1d597593b2";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentWebUrlRedirectInfoOutputRepresentation, existing: ManagedContentWebUrlRedirectInfoOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlRedirectInfoOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentWebUrlRedirectInfoOutputRepresentationNormalized, incoming: ManagedContentWebUrlRedirectInfoOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlRedirectInfoOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * output representation of the redirect information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlRedirectInfoOutputRepresentationNormalized {
+    /** Redirect url of the web url alias. */
+    redirectUrl: string | null;
+}
+/**
+ * output representation of the redirect information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlRedirectInfoOutputRepresentation {
+    redirectUrl: string | null;
+}

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

@@ -0,0 +1,59 @@
+import { ManagedContentAssociatedRecordRepresentation as ManagedContentAssociatedRecordRepresentation_ManagedContentAssociatedRecordRepresentation } from './ManagedContentAssociatedRecordRepresentation';
+import { ManagedContentWebUrlRedirectInfoOutputRepresentation as ManagedContentWebUrlRedirectInfoOutputRepresentation_ManagedContentWebUrlRedirectInfoOutputRepresentation } from './ManagedContentWebUrlRedirectInfoOutputRepresentation';
+import { ManagedContentWebUrlInfoRepresentation as ManagedContentWebUrlInfoRepresentation_ManagedContentWebUrlInfoRepresentation } from './ManagedContentWebUrlInfoRepresentation';
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "18db9d7c38416e3034a59bcb15dd1f2b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    managedContentWebUrlId: string;
+}
+export type ManagedContentWebUrlRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentWebUrlRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): ManagedContentWebUrlRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentWebUrlRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentWebUrlRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentWebUrlRepresentation, existing: ManagedContentWebUrlRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentWebUrlRepresentationNormalized, incoming: ManagedContentWebUrlRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the Web URL Alias information.
+ *
+ * Keys:
+ *    managedContentWebUrlId (string): id
+ */
+export interface ManagedContentWebUrlRepresentationNormalized {
+    /** The associated record details. */
+    associatedRecord: ManagedContentAssociatedRecordRepresentation_ManagedContentAssociatedRecordRepresentation | null;
+    /** Content key of the Web url alias related content. */
+    contentKey: string;
+    /** Web Url Id. */
+    id: string;
+    /** Redirect information of the url alias. */
+    redirectInfo: ManagedContentWebUrlRedirectInfoOutputRepresentation_ManagedContentWebUrlRedirectInfoOutputRepresentation;
+    /** Status of the Web url alias. */
+    status: string;
+    /** Web Url alias of the content. */
+    urlAlias: string;
+    /** List of Url aliases for the content. */
+    urls: Array<ManagedContentWebUrlInfoRepresentation_ManagedContentWebUrlInfoRepresentation>;
+}
+/**
+ * Representation of the Web URL Alias information.
+ *
+ * Keys:
+ *    managedContentWebUrlId (string): id
+ */
+export interface ManagedContentWebUrlRepresentation {
+    associatedRecord: ManagedContentAssociatedRecordRepresentation_ManagedContentAssociatedRecordRepresentation | null;
+    contentKey: string;
+    id: string;
+    redirectInfo: ManagedContentWebUrlRedirectInfoOutputRepresentation_ManagedContentWebUrlRedirectInfoOutputRepresentation;
+    status: string;
+    urlAlias: string;
+    urls: Array<ManagedContentWebUrlInfoRepresentation_ManagedContentWebUrlInfoRepresentation>;
+}

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

@@ -0,0 +1,38 @@
+import { ManagedContentWebUrlRedirectInfoInputRepresentation as ManagedContentWebUrlRedirectInfoInputRepresentation_ManagedContentWebUrlRedirectInfoInputRepresentation } from './ManagedContentWebUrlRedirectInfoInputRepresentation';
+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 = "6f6ae2b093de205945affd10c8a6740e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentWebUrlUpdateInputRepresentation, existing: ManagedContentWebUrlUpdateInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlUpdateInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentWebUrlUpdateInputRepresentationNormalized, incoming: ManagedContentWebUrlUpdateInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlUpdateInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation for updating the WebURL (URL Alias). The body includes either the URL Alias or the External Redirect URL that the user wishes to update, depending on the current state of the Web URL record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlUpdateInputRepresentationNormalized {
+    /** The ID of the record to be associated to the url of the Managed Content */
+    associatedRecordId?: string;
+    /** Body of the update representation */
+    redirectInfo?: ManagedContentWebUrlRedirectInfoInputRepresentation_ManagedContentWebUrlRedirectInfoInputRepresentation;
+    /** status of the request - active/inActive/draft */
+    status?: string;
+    /** The url alias value to be updated for the web url record */
+    urlAlias?: string;
+}
+/**
+ * Input representation for updating the WebURL (URL Alias). The body includes either the URL Alias or the External Redirect URL that the user wishes to update, depending on the current state of the Web URL record.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlUpdateInputRepresentation {
+    associatedRecordId?: string;
+    redirectInfo?: ManagedContentWebUrlRedirectInfoInputRepresentation_ManagedContentWebUrlRedirectInfoInputRepresentation;
+    status?: string;
+    urlAlias?: string;
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentWebUrlRepresentation as ManagedContentWebUrlRepresentation_ManagedContentWebUrlRepresentation } from './ManagedContentWebUrlRepresentation';
+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, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "361f66b21b2d3b6832c42c67fac4f448";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentWebUrlsRepresentation, existing: ManagedContentWebUrlsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentWebUrlsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentWebUrlsRepresentationNormalized, incoming: ManagedContentWebUrlsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentWebUrlsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about url alias for a given managed content in authoring space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlsRepresentationNormalized {
+    /** List of url aliases for content. */
+    urlAliases: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * Information about url alias for a given managed content in authoring space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentWebUrlsRepresentation {
+    urlAliases: Array<ManagedContentWebUrlRepresentation_ManagedContentWebUrlRepresentation>;
+}