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

package/dist/es/es2018/types/src/generated/types/ManagedContentSiteInfoRepresentation.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 = "fa8a60d203ed0a539ebc838b7730a66a";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSiteInfoRepresentation, existing: ManagedContentSiteInfoRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSiteInfoRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSiteInfoRepresentationNormalized, incoming: ManagedContentSiteInfoRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSiteInfoRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Output representation of the site information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSiteInfoRepresentationNormalized {
+    /** Domain Id of the site */
+    domainId: string;
+    /** Site Id of the site */
+    siteId: string;
+}
+/**
+ * Output representation of the site information
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSiteInfoRepresentation {
+    domainId: string;
+    siteId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceBaseTypeRepresentation.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 = "f7501252637637dd58083f1d93351ca5";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceBaseTypeRepresentation, existing: ManagedContentSpaceBaseTypeRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceBaseTypeRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceBaseTypeRepresentationNormalized, incoming: ManagedContentSpaceBaseTypeRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceBaseTypeRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content Space Base Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceBaseTypeRepresentationNormalized {
+    /** Api Name of the base Type */
+    apiName: string | null;
+}
+/**
+ * Details of a Managed Content Space Base Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceBaseTypeRepresentation {
+    apiName: string | null;
+}

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

@@ -0,0 +1,84 @@
+import { ManagedContentSpaceBaseTypeRepresentation as ManagedContentSpaceBaseTypeRepresentation_ManagedContentSpaceBaseTypeRepresentation } from './ManagedContentSpaceBaseTypeRepresentation';
+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, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const TTL = 3600000;
+export declare const VERSION = "44f13d3083ea2235e3214f7012b54f25";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    fullyQualifiedName: string | null;
+}
+export type ManagedContentSpaceByFQNRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentSpaceByFQNRepresentationNormalizedKeyMetadata = 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): ManagedContentSpaceByFQNRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceByFQNRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceByFQNRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentSpaceByFQNRepresentation, existing: ManagedContentSpaceByFQNRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceByFQNRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceByFQNRepresentationNormalized, incoming: ManagedContentSpaceByFQNRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceByFQNRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    fullyQualifiedName (string | null): fullyQualifiedName
+ */
+export interface ManagedContentSpaceByFQNRepresentationNormalized {
+    /** Api Name of the Managed Content Space */
+    apiName?: string | null;
+    /** Base Type of the Managed Content Space */
+    baseType?: ManagedContentSpaceBaseTypeRepresentation_ManagedContentSpaceBaseTypeRepresentation | null;
+    /** 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 | null;
+    /** FQN for the Managed Content Space */
+    fullyQualifiedName: string | null;
+    /** Id of the Managed Content Space */
+    id: string;
+    /** Boolean flag if space is of enhanced type. */
+    isEnhancedSpace?: boolean;
+    /** Boolean flag depiciting orchestrator module installation status */
+    isFlowOrchestrationEnabled: boolean | null;
+    /** Boolean flag of space v2 */
+    isSpaceV2?: boolean;
+    /** 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:
+ *    fullyQualifiedName (string | null): fullyQualifiedName
+ */
+export interface ManagedContentSpaceByFQNRepresentation {
+    apiName?: string | null;
+    baseType?: ManagedContentSpaceBaseTypeRepresentation_ManagedContentSpaceBaseTypeRepresentation | null;
+    createdBy: string;
+    createdDate: string;
+    defaultLanguage: string;
+    description: string | null;
+    fullyQualifiedName: string | null;
+    id: string;
+    isEnhancedSpace?: boolean;
+    isFlowOrchestrationEnabled: boolean | null;
+    isSpaceV2?: boolean;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    name: string;
+    rootFolderId: string;
+    supportedLanguages?: Array<string>;
+}

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

@@ -0,0 +1,30 @@
+import { ManagedContentSpaceRepresentation as ManagedContentSpaceRepresentation_ManagedContentSpaceRepresentation } from './ManagedContentSpaceRepresentation';
+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 = "292efba3a426b62d2af39a38fd3464b0";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceCollectionRepresentation, existing: ManagedContentSpaceCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceCollectionRepresentationNormalized, incoming: ManagedContentSpaceCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection of Managed Content Spaces
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceCollectionRepresentationNormalized {
+    /** ManagedContentSpace records corresponding to the current page. */
+    spaces: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * Collection of Managed Content Spaces
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceCollectionRepresentation {
+    spaces: Array<ManagedContentSpaceRepresentation_ManagedContentSpaceRepresentation>;
+}

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

@@ -0,0 +1,45 @@
+import { ManagedContentSpaceFolderRepresentation as ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation } from './ManagedContentSpaceFolderRepresentation';
+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 = 30000;
+export declare const VERSION = "19a2e59df42998b6d30d4dee5c5a293b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderDetailRepresentation, existing: ManagedContentSpaceFolderDetailRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderDetailRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceFolderDetailRepresentationNormalized, incoming: ManagedContentSpaceFolderDetailRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderDetailRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentationNormalized {
+    /** The User ID of the user who created the folder */
+    createdBy: string;
+    /** The date when the folder was created */
+    createdDate: string;
+    /** The list of the parent folders in the hierarchy - starting from the root upto the direct parent of the folder */
+    folderHierarchy: Array<$64$luvio_engine_StoreLink>;
+    /** Signifies whether the folder is shared or not */
+    isShared: boolean;
+    /** The User ID of the user who last modified the folder */
+    lastModifiedBy: string;
+    /** The date when the folder was last modified */
+    lastModifiedDate: string;
+}
+/**
+ * Detail Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderDetailRepresentation {
+    createdBy: string;
+    createdDate: string;
+    folderHierarchy: Array<ManagedContentSpaceFolderRepresentation_ManagedContentSpaceFolderRepresentation>;
+    isShared: boolean;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceFolderInputRep.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 = "686f011ca27b8ed002b256ce82b32841";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderInputRep, existing: ManagedContentSpaceFolderInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderInputRepNormalized, incoming: ManagedContentSpaceFolderInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a content space folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderInputRepNormalized {
+    /** The name of the folder */
+    name: string;
+    /** Parent folder id */
+    parentFolderId: string;
+}
+/**
+ * Input representation of a content space folder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderInputRep {
+    name: string;
+    parentFolderId: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceFolderItemCollectionInputRep.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 = "d9cfda700d3293277cc91f1818cbbb3f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionInputRep, existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionInputRepNormalized, incoming: ManagedContentSpaceFolderItemCollectionInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRepNormalized {
+    /** ID of the new parent folder to the items should be moved */
+    folderId: string;
+    /** List of IDs of the folder items that need to be moved */
+    folderItems: Array<string>;
+}
+/**
+ * Collection input of ManagedContentSpaceFolderItems for Move operation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionInputRep {
+    folderId: string;
+    folderItems: Array<string>;
+}

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

@@ -0,0 +1,36 @@
+import { ManagedContentSpaceFolderItemRepresentation as ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation } from './ManagedContentSpaceFolderItemRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "e85b8f02eca0f2e88859e6f3a061e56b";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemCollectionRepresentation, existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceFolderItemCollectionRepresentationNormalized, incoming: ManagedContentSpaceFolderItemCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentationNormalized {
+    /** The id of the folder */
+    folderId: string;
+    /** The list of the folder items - ManagedContent or ManagedContentSpaceFolder */
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    /** The id of the parent folder */
+    parentFolderId: string | null;
+}
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemCollectionRepresentation {
+    folderId: string;
+    folderItems: Array<ManagedContentSpaceFolderItemRepresentation_ManagedContentSpaceFolderItemRepresentation>;
+    parentFolderId: string | null;
+}

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

@@ -0,0 +1,80 @@
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+import { ManagedContentLanguageSummaryRepresentation as ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation } from './ManagedContentLanguageSummaryRepresentation';
+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 = "c092d5a49f0de1a0b6be737846456648";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemRepresentation, existing: ManagedContentSpaceFolderItemRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemRepresentationNormalized, incoming: ManagedContentSpaceFolderItemRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentationNormalized {
+    /** The ContentKey of the ManagedContent */
+    contentKey?: string;
+    contentType?: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    /** The User ID for the user which created the ManagedContent or ManagedContentSpaceFolder */
+    createdBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was created */
+    createdDate: string;
+    /** Signifies the type of folder */
+    folderType?: string;
+    /** Boolean flag to indicate whether this folder has child folders */
+    hasChildFolders?: boolean;
+    /** Boolean flag to indicate whether this folder item is a folder */
+    isFolder: boolean;
+    /** Boolean flag to indicate whether this folder item is published */
+    isPublished?: boolean;
+    /** Signifies whether the folder is shared or not */
+    isShared?: boolean;
+    /** Language summary of the ManagedContentVariant */
+    language?: ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation;
+    /** The User ID for the user which last modified the ManagedContentVariant or ManagedContentSpaceFolder */
+    lastModifiedBy: string;
+    /** The User Name for the user which last modified the ManagedContentVariant or ManagedContentSpaceFolder */
+    lastModifiedByName: string;
+    /** The date when the ManagedContentVariant or ManagedContentSpaceFolder was last modified */
+    lastModifiedDate: string;
+    /** The id of the folder item - ManagedContent or ManagedContentSpaceFolder */
+    managedContentOrFolderId: string;
+    /** Latest Managed Content Variant Id of the folder item is ManagedContent */
+    managedContentVariantId?: string;
+    /** The mimetype for the content */
+    mimeType: string;
+    /** Status of the ManagedContentVariant */
+    status?: string;
+    /** Title of the ManagedContent/ManagedContentSpaceFolder */
+    title: string;
+}
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemRepresentation {
+    contentKey?: string;
+    contentType?: ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation;
+    createdBy: string;
+    createdDate: string;
+    folderType?: string;
+    hasChildFolders?: boolean;
+    isFolder: boolean;
+    isPublished?: boolean;
+    isShared?: boolean;
+    language?: ManagedContentLanguageSummaryRepresentation_ManagedContentLanguageSummaryRepresentation;
+    lastModifiedBy: string;
+    lastModifiedByName: string;
+    lastModifiedDate: string;
+    managedContentOrFolderId: string;
+    managedContentVariantId?: string;
+    mimeType: string;
+    status?: string;
+    title: string;
+}

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

@@ -0,0 +1,36 @@
+import { ManagedContentSpaceFolderItemV1Representation as ManagedContentSpaceFolderItemV1Representation_ManagedContentSpaceFolderItemV1Representation } from './ManagedContentSpaceFolderItemV1Representation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, BaseFragment as $64$luvio_engine_BaseFragment, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const TTL = 100;
+export declare const VERSION = "df1370994ae2e57cdebc5f5125930e2d";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemV1CollectionRepresentation, existing: ManagedContentSpaceFolderItemV1CollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemV1CollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceFolderItemV1CollectionRepresentationNormalized, incoming: ManagedContentSpaceFolderItemV1CollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemV1CollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemV1CollectionRepresentationNormalized {
+    /** The id of the folder */
+    folderId: string;
+    /** The list of the folder items - ManagedContent or ManagedContentSpaceFolder */
+    folderItems: Array<ManagedContentSpaceFolderItemV1Representation_ManagedContentSpaceFolderItemV1Representation>;
+    /** The id of the parent folder */
+    parentFolderId: string | null;
+}
+/**
+ * Collection Representation of folder items inside in ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemV1CollectionRepresentation {
+    folderId: string;
+    folderItems: Array<ManagedContentSpaceFolderItemV1Representation_ManagedContentSpaceFolderItemV1Representation>;
+    parentFolderId: string | null;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceFolderItemV1Representation.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 = "174efbd1f2c0ef436b65fd72cc9d4ae3";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceFolderItemV1Representation, existing: ManagedContentSpaceFolderItemV1RepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderItemV1RepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceFolderItemV1RepresentationNormalized, incoming: ManagedContentSpaceFolderItemV1RepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderItemV1Representation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemV1RepresentationNormalized {
+    /** The ContentKey of the ManagedContent */
+    contentKey?: string;
+    /** The User ID for the user which created the ManagedContent or ManagedContentSpaceFolder */
+    createdBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was created */
+    createdDate: string;
+    /** Boolean flag to indicate whether this folder has child folders */
+    hasChildFolders?: boolean;
+    /** The id of the folder item - ManagedContent or ManagedContentSpaceFolder */
+    id?: string;
+    /** Boolean flag to indicate whether this folder item is a folder */
+    isFolder: boolean;
+    /** The User ID for the user which last modified the ManagedContent or ManagedContentSpaceFolder */
+    lastModifiedBy: string;
+    /** The date when the ManagedContent or ManagedContentSpaceFolder was last modified */
+    lastModifiedDate: string;
+    /** Developer Name for the ManagedContentType if the folder item is ManagedContent */
+    managedContentType?: string;
+    /** Latest Managed Content Version Id of the folder item is ManagedContent */
+    managedContentVersionId?: string;
+    /** Date when the ManagedContent was last published */
+    publishedDate?: string;
+    /** Status of the Managed Content */
+    status?: string;
+    /** Title of the ManagedContent/ManagedContentSpaceFolder */
+    title: string;
+}
+/**
+ * Representation of a folder item inside a ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceFolderItemV1Representation {
+    contentKey?: string;
+    createdBy: string;
+    createdDate: string;
+    hasChildFolders?: boolean;
+    id?: string;
+    isFolder: boolean;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    managedContentType?: string;
+    managedContentVersionId?: string;
+    publishedDate?: string;
+    status?: string;
+    title: string;
+}

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

@@ -0,0 +1,44 @@
+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 = "6cb5e79d281317772f97d55182ce890e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    id: string;
+}
+export type ManagedContentSpaceFolderRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentSpaceFolderRepresentationNormalizedKeyMetadata = 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): ManagedContentSpaceFolderRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceFolderRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceFolderRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentSpaceFolderRepresentation, existing: ManagedContentSpaceFolderRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceFolderRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentSpaceFolderRepresentationNormalized, incoming: ManagedContentSpaceFolderRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceFolderRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Base Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentSpaceFolderRepresentationNormalized {
+    /** The id for the folder */
+    id: string;
+    /** The name of the folder */
+    name: string;
+    /** The parent folder id */
+    parentFolderId: string | null;
+}
+/**
+ * Base Representation of a CMS Folder i.e. ManagedContentSpaceFolder
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentSpaceFolderRepresentation {
+    id: string;
+    name: string;
+    parentFolderId: string | null;
+}

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

@@ -0,0 +1,62 @@
+import { ManagedContentSpaceMemberInputRepresentation as ManagedContentSpaceMemberInputRepresentation_ManagedContentSpaceMemberInputRepresentation } from './ManagedContentSpaceMemberInputRepresentation';
+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 = "7bb94937a75a84627a372965b9b4bd82";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceInputRepresentation, existing: ManagedContentSpaceInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceInputRepresentationNormalized, incoming: ManagedContentSpaceInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The input representation for a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceInputRepresentationNormalized {
+    /** Api Name of the Managed Content Space */
+    apiName?: string;
+    /** Optional business unit id to associate with the space */
+    businessUnitId?: string;
+    /** List of CMS Channels to be associated with the Managed Content Space */
+    channelsList?: Array<string>;
+    /** List of contributors to be associated with the Managed Content Space */
+    collaboratorsList?: Array<ManagedContentSpaceMemberInputRepresentation_ManagedContentSpaceMemberInputRepresentation>;
+    /** Default Language of the Managed Content Space */
+    defaultLanguage?: string;
+    /** Description of the Managed Content Space */
+    description?: string;
+    /** Boolean flag depiciting orchestrator module installation status associated with the Managed Content Space */
+    isFlowOrchestrationEnabled?: boolean;
+    /** Boolean flag depicting space as 2.0 if set true */
+    isSpaceV2?: boolean;
+    /** Boolean flag depicting space as undeletable if set true */
+    isUndeletable?: boolean;
+    /** Name of the Managed Content Space */
+    name?: string;
+    /** Space type of the Managed Content Space */
+    spaceType?: string;
+    /** List of languages supported by the Managed Content Space */
+    supportedLanguagesList?: Array<string>;
+}
+/**
+ * The input representation for a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceInputRepresentation {
+    apiName?: string;
+    businessUnitId?: string;
+    channelsList?: Array<string>;
+    collaboratorsList?: Array<ManagedContentSpaceMemberInputRepresentation_ManagedContentSpaceMemberInputRepresentation>;
+    defaultLanguage?: string;
+    description?: string;
+    isFlowOrchestrationEnabled?: boolean;
+    isSpaceV2?: boolean;
+    isUndeletable?: boolean;
+    name?: string;
+    spaceType?: string;
+    supportedLanguagesList?: Array<string>;
+}