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

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

@@ -0,0 +1,46 @@
+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 = "f7ab01e8e6806fded8c7131ffbe5d0dc";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpacePermissionRepresentation, existing: ManagedContentSpacePermissionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpacePermissionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpacePermissionRepresentationNormalized, incoming: ManagedContentSpacePermissionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpacePermissionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a permission bit vector based on a scopeType or contentTypeIdOrEnum
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpacePermissionRepresentationNormalized {
+    /** Does the member have create access for the scopeType and spaceContentType */
+    canCreate: boolean;
+    /** Does the member have delete access for the scopeType and spaceContentType */
+    canDelete: boolean;
+    /** Does the member have manage access for the scopeType and spaceContentType */
+    canManage: boolean;
+    /** Does the member have publish/unpublish access for the scopeType and spaceContentType */
+    canPublish: boolean;
+    /** Does the member have read access for the scopeType and spaceContentType */
+    canRead: boolean;
+    /** Does the member have translate access for the scopeType and spaceContentType */
+    canTranslate: boolean;
+    /** Does the member have update access for the scopeType and spaceContentType */
+    canUpdate: boolean;
+}
+/**
+ * Representation of a permission bit vector based on a scopeType or contentTypeIdOrEnum
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpacePermissionRepresentation {
+    canCreate: boolean;
+    canDelete: boolean;
+    canManage: boolean;
+    canPublish: boolean;
+    canRead: boolean;
+    canTranslate: boolean;
+    canUpdate: boolean;
+}

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

@@ -0,0 +1,55 @@
+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 = "9742049591a0f7a9f6718f4a18b565b7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRepresentation, existing: ManagedContentSpaceRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRepresentationNormalized, incoming: ManagedContentSpaceRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRepresentationNormalized {
+    /** User-Id of the creator of the Managed Content Space */
+    createdBy: string;
+    /** Date of creation of the Managed Content Space */
+    createdDate: string;
+    /** Default Language of the Managed Content Space */
+    defaultLanguage: string;
+    /** Description of the Managed Content Space */
+    description: string;
+    /** Id of the Managed Content Space */
+    id: string;
+    /** User-Id of the user who last modified the Managed Content Space */
+    lastModifiedBy: string;
+    /** Date on which the Managed Content Space was last modified */
+    lastModifiedDate: string;
+    /** Name of the Managed Content Space */
+    name: string;
+    /** Root Folder Id of the Managed Content Space */
+    rootFolderId: string;
+    /** Set of supported languages in the Managed Content Space */
+    supportedLanguages: Array<string>;
+}
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRepresentation {
+    createdBy: string;
+    createdDate: string;
+    defaultLanguage: string;
+    description: string;
+    id: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    name: string;
+    rootFolderId: string;
+    supportedLanguages: Array<string>;
+}

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

@@ -0,0 +1,29 @@
+import { ManagedContentSpaceRoleRepresentation as ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation } from './ManagedContentSpaceRoleRepresentation';
+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 = "332f49232e25346824252c100fc484bd";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRoleCollectionRepresentation, existing: ManagedContentSpaceRoleCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRoleCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRoleCollectionRepresentationNormalized, incoming: ManagedContentSpaceRoleCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRoleCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection representation of the roles in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleCollectionRepresentationNormalized {
+    /** List of the roles in the content space */
+    roles: Array<ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation>;
+}
+/**
+ * Collection representation of the roles in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleCollectionRepresentation {
+    roles: Array<ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation>;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceRoleRepresentation.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 = "b5f70db0d211782d4a07f0c4b75fea95";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceRoleRepresentation, existing: ManagedContentSpaceRoleRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceRoleRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceRoleRepresentationNormalized, incoming: ManagedContentSpaceRoleRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceRoleRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a ManagedContentSpaceRole
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleRepresentationNormalized {
+    /** The role description */
+    description: string;
+    /** The role ID */
+    id: string;
+    /** The role name */
+    name: string;
+}
+/**
+ * Representation of a ManagedContentSpaceRole
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceRoleRepresentation {
+    description: string;
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,30 @@
+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 = "73b81646c0ca6dcfd69e957aedca7ea7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTextNodeValueRepresentation, existing: ManagedContentTextNodeValueRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTextNodeValueRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTextNodeValueRepresentationNormalized, incoming: ManagedContentTextNodeValueRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTextNodeValueRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content node of type text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTextNodeValueRepresentationNormalized extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    /** The text value of the managed content node. */
+    value: string;
+}
+/**
+ * Information about a managed content node of type text.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTextNodeValueRepresentation extends ManagedContentNodeValueRepresentation_ManagedContentNodeValueRepresentation {
+    value: string;
+    nodeType: 'Text';
+}

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

@@ -0,0 +1,64 @@
+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 = "b5bdf6efbbc1fb2c98d0b9eb3c28ec0c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTranslationRepresentation, existing: ManagedContentTranslationRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTranslationRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTranslationRepresentationNormalized, incoming: ManagedContentTranslationRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTranslationRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content translation job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationRepresentationNormalized {
+    /** The user id who created the managed content translation job */
+    createdBy: string;
+    /** The created date of the managed content translation job */
+    createdDate: string;
+    /** The URL to get the error content body of a managed content translation job */
+    errorBodyUrl: string;
+    /** The id of a managed content translation job */
+    id: string;
+    /** The URL to get the input content body of a managed content translation job */
+    inputBodyUrl: string;
+    /** The type of a managed content translation job */
+    jobType: string;
+    /** The last user id who has modified the managed content translation job */
+    lastModifiedBy: string;
+    /** The last time the managed content translation job has been modified */
+    lastModifiedDate: string;
+    /** The last status update date of a managed content translation job */
+    lastStatusUpdateDate: string;
+    /** The name of a managed content translation job */
+    name: string;
+    /** The URL to get the output content body of a managed content translation job */
+    outputBodyUrl: string;
+    /** The start date of a managed content translation job */
+    startDate: string;
+    /** The status of a managed content translation job */
+    status: string;
+}
+/**
+ * Information about a managed content translation job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationRepresentation {
+    createdBy: string;
+    createdDate: string;
+    errorBodyUrl: string;
+    id: string;
+    inputBodyUrl: string;
+    jobType: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    lastStatusUpdateDate: string;
+    name: string;
+    outputBodyUrl: string;
+    startDate: string;
+    status: string;
+}

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

@@ -0,0 +1,37 @@
+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 = "73c2052f831979455b714eaaffca2e3d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTranslationRequestInputRep, existing: ManagedContentTranslationRequestInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTranslationRequestInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTranslationRequestInputRepNormalized, incoming: ManagedContentTranslationRequestInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTranslationRequestInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a translation request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationRequestInputRepNormalized {
+    /** Indicates the content body id of the translation */
+    contentBodyId: string;
+    /** Managed Content Space Id */
+    managedContentSpaceId: string;
+    /** Indicates the name of the translation */
+    name: string;
+    /** Indicates the type of the translation */
+    type: string;
+}
+/**
+ * Input representation of a translation request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationRequestInputRep {
+    contentBodyId: string;
+    managedContentSpaceId: string;
+    name: string;
+    type: string;
+}

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

@@ -0,0 +1,39 @@
+import { ManagedContentNodeTypeRepresentation as ManagedContentNodeTypeRepresentation_ManagedContentNodeTypeRepresentation } from './ManagedContentNodeTypeRepresentation';
+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 = "a2a39672d73c5fc1b85a40a79c024f57";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeRepresentation, existing: ManagedContentTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeRepresentationNormalized, incoming: ManagedContentTypeRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeRepresentationNormalized {
+    /** The label of the managed content type.. */
+    label: string;
+    /** The developer name of the  managed content type. */
+    name: string;
+    /** The collection of node types in this managed content type.. */
+    nodeTypes: {
+        [key: string]: ManagedContentNodeTypeRepresentation_ManagedContentNodeTypeRepresentation;
+    };
+}
+/**
+ * Information about a managed content type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeRepresentation {
+    label: string;
+    name: string;
+    nodeTypes: {
+        [key: string]: ManagedContentNodeTypeRepresentation_ManagedContentNodeTypeRepresentation;
+    };
+}

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

@@ -0,0 +1,38 @@
+import { ManagedContentTypeSearchableRepresentation as ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation } from './ManagedContentTypeSearchableRepresentation';
+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 = "a8a32a6ec22fd17bf143c7771d77fcda";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableCollectionRepresentation, existing: ManagedContentTypeSearchableCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableCollectionRepresentationNormalized, incoming: ManagedContentTypeSearchableCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableCollectionRepresentationNormalized {
+    /** URL to the current page of Manage Content Type Search Status records. The default is 25 managed content channels per page. */
+    currentPageUrl: string;
+    /** Manage Content Type Searchable records corresponding to the current page */
+    items: Array<ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation>;
+    /** URL to the next page of Manage Content Type Search Status records. The default is 25 managed content channels per page. */
+    nextPageUrl: string;
+    /** Total count of Manage Content Type Search Status records across all pages */
+    totalItems: number;
+}
+/**
+ * Collection of Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableCollectionRepresentation {
+    currentPageUrl: string;
+    items: Array<ManagedContentTypeSearchableRepresentation_ManagedContentTypeSearchableRepresentation>;
+    nextPageUrl: string;
+    totalItems: number;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentTypeSearchableInputRepresentation.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 = "252d902ecbe79b3576c4ca5293006f4e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableInputRepresentation, existing: ManagedContentTypeSearchableInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableInputRepresentationNormalized, incoming: ManagedContentTypeSearchableInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The input representation for a content type search status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableInputRepresentationNormalized {
+    /** Searchable status of the Content Type */
+    isSearchable: boolean;
+    /** Name of the Content Type */
+    name: string;
+}
+/**
+ * The input representation for a content type search status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableInputRepresentation {
+    isSearchable: boolean;
+    name: string;
+}

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

@@ -0,0 +1,37 @@
+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 = "39f5f40a7cb00564def69cc8aa583c84";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSearchableRepresentation, existing: ManagedContentTypeSearchableRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSearchableRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSearchableRepresentationNormalized, incoming: ManagedContentTypeSearchableRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSearchableRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableRepresentationNormalized {
+    /** Id of the Managed Content Type */
+    id: string;
+    /** Is the contentType searchable */
+    isSearchable: boolean;
+    /** Master label of the Managed Content Type */
+    label: string;
+    /** Developer Name of the Managed Content Type */
+    name: string;
+}
+/**
+ * Details of a Managed Content Type Search Status
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSearchableRepresentation {
+    id: string;
+    isSearchable: boolean;
+    label: string;
+    name: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentTypeSummaryRepresentation.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 = "7297fb0dbfe8f664d76179a65037c290";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSummaryRepresentation, existing: ManagedContentTypeSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSummaryRepresentationNormalized, incoming: ManagedContentTypeSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSummaryRepresentationNormalized {
+    /** fully qualified name of a managed content type. */
+    fullyQualifiedName: string;
+    /** name of a managed content type. */
+    name?: string;
+}
+/**
+ * Information about a managed content type.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSummaryRepresentation {
+    fullyQualifiedName: string;
+    name?: string;
+}

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

@@ -0,0 +1,46 @@
+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 = "e8f550395c5ec4b897b0deb923da575c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVariantInputRep, existing: ManagedContentVariantInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVariantInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVariantInputRepNormalized, incoming: ManagedContentVariantInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVariantInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a managed content variant request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantInputRepNormalized {
+    /** Indicates the body of a variation */
+    body: {};
+    /** Indicates the language of a variation */
+    language: string;
+    /** Managed Content Version Id */
+    managedContentVersionId: string;
+    /** Indicates the name of a variation */
+    name: string;
+    /** Indicates the parent id of a variation */
+    parentId: string;
+    /** Indicates the type of the ManagedContentVariant */
+    type: string;
+    /** Indicates the url name of a variation */
+    urlName: string;
+}
+/**
+ * Input representation of a managed content variant request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantInputRep {
+    body: {};
+    language: string;
+    managedContentVersionId: string;
+    name: string;
+    parentId: string;
+    type: string;
+    urlName: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentVariantRepresentation.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 = "94877a88c510715d15a4b49c2588d667";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVariantRepresentation, existing: ManagedContentVariantRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVariantRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentVariantRepresentationNormalized, incoming: ManagedContentVariantRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVariantRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content variant
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantRepresentationNormalized {
+    /** The body of a managed content variant */
+    body: string;
+    /** The id of a managed content variant */
+    id: string;
+    /** The language of a managed content variant */
+    language: string;
+    /** The id of a managed content version */
+    managedContentVersionId: string;
+    /** The name of a managed content variant */
+    name: string;
+    /** The id of a parent */
+    parentId: string;
+    /** The url name of a managed content variant */
+    urlName: string;
+    /** The variant of a managed content variant */
+    variantType: string;
+}
+/**
+ * Information about a managed content variant
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVariantRepresentation {
+    body: string;
+    id: string;
+    language: string;
+    managedContentVersionId: string;
+    name: string;
+    parentId: string;
+    urlName: string;
+    variantType: string;
+}

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

@@ -0,0 +1,50 @@
+import { ManagedContentVersionRepresentation as ManagedContentVersionRepresentation_ManagedContentVersionRepresentation } from './ManagedContentVersionRepresentation';
+import { ManagedContentTypeRepresentation as ManagedContentTypeRepresentation_ManagedContentTypeRepresentation } from './ManagedContentTypeRepresentation';
+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 = 3600000;
+export declare const VERSION = "5ee006120d0880559392ef3c5fdc2a52";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentVersionCollectionRepresentation, existing: ManagedContentVersionCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentVersionCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentVersionCollectionRepresentationNormalized, incoming: ManagedContentVersionCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentVersionCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of managed content versions.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionCollectionRepresentationNormalized {
+    /** URL to the current page of managed content versions. The default is 25 managed content versions per page. */
+    currentPageUrl: string;
+    /** Managed content versions for this page. */
+    items: Array<ManagedContentVersionRepresentation_ManagedContentVersionRepresentation>;
+    /** Managed content types for this page. */
+    managedContentTypes?: {
+        [key: string]: ManagedContentTypeRepresentation_ManagedContentTypeRepresentation;
+    };
+    /** URL to the next page of managed content versions, The default is 25 managed content versions per page. */
+    nextPageUrl?: string;
+    /** Total number of versions across all pages. */
+    total: number;
+    /** Total number of content types across all pages. */
+    totalTypes: number;
+}
+/**
+ * Collection of managed content versions.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentVersionCollectionRepresentation {
+    currentPageUrl: string;
+    items: Array<ManagedContentVersionRepresentation_ManagedContentVersionRepresentation>;
+    managedContentTypes?: {
+        [key: string]: ManagedContentTypeRepresentation_ManagedContentTypeRepresentation;
+    };
+    nextPageUrl?: string;
+    total: number;
+    totalTypes: number;
+}