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

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

@@ -0,0 +1,28 @@
+import { ManagedContentSpaceInputRepresentation as ManagedContentSpaceInputRepresentation_ManagedContentSpaceInputRepresentation } from './ManagedContentSpaceInputRepresentation';
+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 = "46224b666928632ec182b2329723706f";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceInputWrapperRepresentation, existing: ManagedContentSpaceInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceInputWrapperRepresentationNormalized, incoming: ManagedContentSpaceInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper around input representation for Managed Content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceInputWrapperRepresentationNormalized {
+    ManagedContentSpaceInput: ManagedContentSpaceInputRepresentation_ManagedContentSpaceInputRepresentation;
+}
+/**
+ * Wrapper around input representation for Managed Content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceInputWrapperRepresentation {
+    ManagedContentSpaceInput: ManagedContentSpaceInputRepresentation_ManagedContentSpaceInputRepresentation;
+}

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

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

package/dist/es/es2018/types/src/generated/types/ManagedContentSpaceMemberInputRepresentation.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 = "aa02c2b3dc29696236da41cfa5c2fccb";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberInputRepresentation, existing: ManagedContentSpaceMemberInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberInputRepresentationNormalized, incoming: ManagedContentSpaceMemberInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a content space member
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberInputRepresentationNormalized {
+    /** The ID of the user/group to assign the role in the content space */
+    memberId: string;
+    /** The ID of the role to assign the user as, in the content space */
+    roleId: string;
+}
+/**
+ * Input representation of a content space member
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberInputRepresentation {
+    memberId: string;
+    roleId: string;
+}

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

@@ -0,0 +1,37 @@
+import { ManagedContentSpacePermissionRepresentation as ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation } from './ManagedContentSpacePermissionRepresentation';
+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 = "084fc7931f796f3ea348be92f513babe";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberPermissionsRepresentation, existing: ManagedContentSpaceMemberPermissionsRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberPermissionsRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberPermissionsRepresentationNormalized, incoming: ManagedContentSpaceMemberPermissionsRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberPermissionsRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of permissions of a member in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberPermissionsRepresentationNormalized {
+    /** A map of permissions for a member grouped by different scopes and consequently spaceContentTypes */
+    permissions: {
+        [key: string]: {
+            [key: string]: ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation;
+        };
+    };
+}
+/**
+ * Representation of permissions of a member in a content space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberPermissionsRepresentation {
+    permissions: {
+        [key: string]: {
+            [key: string]: ManagedContentSpacePermissionRepresentation_ManagedContentSpacePermissionRepresentation;
+        };
+    };
+}

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

@@ -0,0 +1,34 @@
+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 = "ce923c41b95874dccf972705c4f25f77";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceMemberRepresentation, existing: ManagedContentSpaceMemberRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceMemberRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceMemberRepresentationNormalized, incoming: ManagedContentSpaceMemberRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceMemberRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of a ManagedContentSpaceMember
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberRepresentationNormalized {
+    /** The id of managedContentSpaceMember entity object */
+    id: string;
+    /** The user / group id */
+    memberId: string;
+    role: ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation;
+}
+/**
+ * Representation of a ManagedContentSpaceMember
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceMemberRepresentation {
+    id: string;
+    memberId: string;
+    role: ManagedContentSpaceRoleRepresentation_ManagedContentSpaceRoleRepresentation;
+}

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

@@ -0,0 +1,52 @@
+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 = "eaaea3c665b418873ba8940edb51e5da";
+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 manage access for the scopeType and spaceContentType */
+    canPreview: 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 schedule access for the scopeType and spaceContentType */
+    canSchedule: 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;
+    canPreview: boolean;
+    canPublish: boolean;
+    canRead: boolean;
+    canSchedule: boolean;
+    canTranslate: boolean;
+    canUpdate: boolean;
+}

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

@@ -0,0 +1,88 @@
+import { ManagedContentBusinessUnitRepresentation as ManagedContentBusinessUnitRepresentation_ManagedContentBusinessUnitRepresentation } from './ManagedContentBusinessUnitRepresentation';
+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, 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 = "f7830b7686da64a5194c2069ff435a38";
+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 ManagedContentSpaceRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentSpaceRepresentationNormalizedKeyMetadata = 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): ManagedContentSpaceRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentSpaceRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+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_BaseFragment;
+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:
+ *    id (string): id
+ */
+export interface ManagedContentSpaceRepresentationNormalized {
+    /** Api Name of the Managed Content Space */
+    apiName?: string | null;
+    /** Business unit associated with the Managed Content Space. */
+    businessUnit: ManagedContentBusinessUnitRepresentation_ManagedContentBusinessUnitRepresentation | 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;
+    /** Base Type of the Managed Content Space */
+    spaceType?: ManagedContentSpaceBaseTypeRepresentation_ManagedContentSpaceBaseTypeRepresentation | null;
+    /** Set of supported languages in the Managed Content Space */
+    supportedLanguages?: Array<string>;
+}
+/**
+ * Details of a Managed Content Space
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentSpaceRepresentation {
+    apiName?: string | null;
+    businessUnit: ManagedContentBusinessUnitRepresentation_ManagedContentBusinessUnitRepresentation | 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;
+    spaceType?: ManagedContentSpaceBaseTypeRepresentation_ManagedContentSpaceBaseTypeRepresentation | null;
+    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/ManagedContentSpaceSummaryRepresentation.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 = "577d4cf32ca399b09e4ba4e247533276";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceSummaryRepresentation, existing: ManagedContentSpaceSummaryRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceSummaryRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceSummaryRepresentationNormalized, incoming: ManagedContentSpaceSummaryRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceSummaryRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceSummaryRepresentationNormalized {
+    /** Id of the managed content space. */
+    id: string;
+    /** Connect API resource url to ge more information about managed content space. */
+    resourceUrl: string;
+}
+/**
+ * Information about a managed content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceSummaryRepresentation {
+    id: string;
+    resourceUrl: string;
+}

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

@@ -0,0 +1,50 @@
+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 = "c837aa2e238465b9865da8e2d38cd988";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceUpdateInputRepresentation, existing: ManagedContentSpaceUpdateInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceUpdateInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceUpdateInputRepresentationNormalized, incoming: ManagedContentSpaceUpdateInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceUpdateInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * The input representation to update a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceUpdateInputRepresentationNormalized {
+    /** Api Name of the Managed Content Space */
+    apiName?: 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>;
+    /** 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;
+    /** Name of the Managed Content Space */
+    name?: string;
+    /** List of languages supported by the Managed Content Space */
+    supportedLanguagesList?: Array<string>;
+}
+/**
+ * The input representation to update a Managed Content Space
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceUpdateInputRepresentation {
+    apiName?: string;
+    channelsList?: Array<string>;
+    collaboratorsList?: Array<ManagedContentSpaceMemberInputRepresentation_ManagedContentSpaceMemberInputRepresentation>;
+    description?: string;
+    isFlowOrchestrationEnabled?: boolean;
+    isSpaceV2?: boolean;
+    name?: string;
+    supportedLanguagesList?: Array<string>;
+}

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

@@ -0,0 +1,28 @@
+import { ManagedContentSpaceUpdateInputRepresentation as ManagedContentSpaceUpdateInputRepresentation_ManagedContentSpaceUpdateInputRepresentation } from './ManagedContentSpaceUpdateInputRepresentation';
+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 = "c5fd590e0a654380b0b34bc52e420564";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentSpaceUpdateInputWrapperRepresentation, existing: ManagedContentSpaceUpdateInputWrapperRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentSpaceUpdateInputWrapperRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentSpaceUpdateInputWrapperRepresentationNormalized, incoming: ManagedContentSpaceUpdateInputWrapperRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentSpaceUpdateInputWrapperRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper around update input representation for Managed Content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceUpdateInputWrapperRepresentationNormalized {
+    ManagedContentSpaceUpdateInput: ManagedContentSpaceUpdateInputRepresentation_ManagedContentSpaceUpdateInputRepresentation;
+}
+/**
+ * Wrapper around update input representation for Managed Content space.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentSpaceUpdateInputWrapperRepresentation {
+    ManagedContentSpaceUpdateInput: ManagedContentSpaceUpdateInputRepresentation_ManagedContentSpaceUpdateInputRepresentation;
+}

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

@@ -0,0 +1,41 @@
+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 = 100;
+export declare const VERSION = "3cd34ee5825411ca0a394a99afae43e7";
+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 ManagedContentTaxonomyPathFragmentRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentTaxonomyPathFragmentRepresentationNormalizedKeyMetadata = 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): ManagedContentTaxonomyPathFragmentRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyPathFragmentRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyPathFragmentRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentTaxonomyPathFragmentRepresentation, existing: ManagedContentTaxonomyPathFragmentRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTaxonomyPathFragmentRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTaxonomyPathFragmentRepresentationNormalized, incoming: ManagedContentTaxonomyPathFragmentRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTaxonomyPathFragmentRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * A fragment of a path in a content taxonomy, representing information about a term or the taxonomy.
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTaxonomyPathFragmentRepresentationNormalized {
+    /** The ID of the term or the taxonomy. */
+    id: string;
+    /** The label of the term or the taxonomy. */
+    label: string;
+}
+/**
+ * A fragment of a path in a content taxonomy, representing information about a term or the taxonomy.
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTaxonomyPathFragmentRepresentation {
+    id: string;
+    label: string;
+}

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

@@ -0,0 +1,36 @@
+import { ManagedContentTaxonomyPathFragmentRepresentation as ManagedContentTaxonomyPathFragmentRepresentation_ManagedContentTaxonomyPathFragmentRepresentation } from './ManagedContentTaxonomyPathFragmentRepresentation';
+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 = "861a01549e9c8877564cf9109fe8af72";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTaxonomyPathRepresentation, existing: ManagedContentTaxonomyPathRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTaxonomyPathRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentTaxonomyPathRepresentationNormalized, incoming: ManagedContentTaxonomyPathRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTaxonomyPathRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * A path to a term in a content taxonomy.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTaxonomyPathRepresentationNormalized {
+    /** A text representation of the path from the root, joined with a delimiter. */
+    label: string;
+    /** A path fragment representing the taxonomy. */
+    taxonomyFragment: $64$luvio_engine_StoreLink;
+    /** Path fragments representing the terms from root term to this term, inclusive. */
+    termFragments: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * A path to a term in a content taxonomy.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTaxonomyPathRepresentation {
+    label: string;
+    taxonomyFragment: ManagedContentTaxonomyPathFragmentRepresentation_ManagedContentTaxonomyPathFragmentRepresentation;
+    termFragments: Array<ManagedContentTaxonomyPathFragmentRepresentation_ManagedContentTaxonomyPathFragmentRepresentation>;
+}

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

@@ -0,0 +1,54 @@
+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, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+import { ManagedContentTaxonomyTermRepresentation as ManagedContentTaxonomyTermRepresentation_ManagedContentTaxonomyTermRepresentation } from './ManagedContentTaxonomyTermRepresentation';
+export declare const TTL = 100;
+export declare const VERSION = "8ab64b2a71caa7cbdb25a65e8081196c";
+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 | null;
+}
+export type ManagedContentTaxonomyTermCollectionRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentTaxonomyTermCollectionRepresentationNormalizedKeyMetadata = 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): ManagedContentTaxonomyTermCollectionRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyTermCollectionRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyTermCollectionRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentTaxonomyTermCollectionRepresentation, existing: ManagedContentTaxonomyTermCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTaxonomyTermCollectionRepresentationNormalized;
+export interface DynamicIngestParams {
+    taxonomyTerms: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ManagedContentTaxonomyTermCollectionRepresentation, existing: ManagedContentTaxonomyTermCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ManagedContentTaxonomyTermCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    taxonomyTerms?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTaxonomyTermCollectionRepresentationNormalized, incoming: ManagedContentTaxonomyTermCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTaxonomyTermCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * A collection of content taxonomy terms.
+ *
+ * Keys:
+ *    id (string | null): managedContentId
+ */
+export interface ManagedContentTaxonomyTermCollectionRepresentationNormalized {
+    /** Unique identifier of a managed content that is unchanged by org migration. */
+    contentKey: string | null;
+    /** Id of the managed content in authoring space. */
+    managedContentId: string | null;
+    /** The list of taxonomy terms associated with content. */
+    taxonomyTerms: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * A collection of content taxonomy terms.
+ *
+ * Keys:
+ *    id (string | null): managedContentId
+ */
+export interface ManagedContentTaxonomyTermCollectionRepresentation {
+    contentKey: string | null;
+    managedContentId: string | null;
+    taxonomyTerms: Array<ManagedContentTaxonomyTermRepresentation_ManagedContentTaxonomyTermRepresentation>;
+}