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

package/dist/es/es2018/types/src/generated/types/ManagedContentTaxonomyTermRepresentation.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 { ManagedContentTaxonomyPathRepresentation as ManagedContentTaxonomyPathRepresentation_ManagedContentTaxonomyPathRepresentation } from './ManagedContentTaxonomyPathRepresentation';
+export declare const TTL = 100;
+export declare const VERSION = "ac799a7cee04dda27b43cff95ee1aee5";
+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 ManagedContentTaxonomyTermRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentTaxonomyTermRepresentationNormalizedKeyMetadata = 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): ManagedContentTaxonomyTermRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyTermRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentTaxonomyTermRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentTaxonomyTermRepresentation, existing: ManagedContentTaxonomyTermRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTaxonomyTermRepresentationNormalized;
+export interface DynamicIngestParams {
+    pathsFromRoot: $64$luvio_engine_ResourceIngest;
+}
+export declare function dynamicNormalize(ingestParams: DynamicIngestParams): (input: ManagedContentTaxonomyTermRepresentation, existing: ManagedContentTaxonomyTermRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number) => ManagedContentTaxonomyTermRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export interface DynamicSelectParams {
+    pathsFromRoot?: $64$luvio_engine_LinkSelection;
+}
+export declare const dynamicSelect: (params: DynamicSelectParams) => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTaxonomyTermRepresentationNormalized, incoming: ManagedContentTaxonomyTermRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTaxonomyTermRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$luvio_engine_ResourceIngest;
+/**
+ * A content taxonomy term associated to managed content.
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTaxonomyTermRepresentationNormalized {
+    /** The ID of the term. */
+    id: string;
+    /** The label of the term. */
+    label: string;
+    /** The path(s) from a root term to this term. */
+    pathsFromRoot: Array<$64$luvio_engine_StoreLink>;
+}
+/**
+ * A content taxonomy term associated to managed content.
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTaxonomyTermRepresentation {
+    id: string;
+    label: string;
+    pathsFromRoot: Array<ManagedContentTaxonomyPathRepresentation_ManagedContentTaxonomyPathRepresentation>;
+}

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

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, 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 = "e14144ec5555df76fcc9dac4388e7ea8";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTaxonomyTermsInputRepresentation, existing: ManagedContentTaxonomyTermsInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTaxonomyTermsInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentTaxonomyTermsInputRepresentationNormalized, incoming: ManagedContentTaxonomyTermsInputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTaxonomyTermsInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input to add or remove Taxonomy terms associated to Managed Content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTaxonomyTermsInputRepresentationNormalized {
+    /** List of IDs of the taxonomy terms that need to be added. */
+    termsToAdd: Array<string>;
+    /** List of IDs of the taxonomy terms that need to be removed. */
+    termsToRemove: Array<string>;
+}
+/**
+ * Input to add or remove Taxonomy terms associated to Managed Content.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTaxonomyTermsInputRepresentation {
+    termsToAdd: Array<string>;
+    termsToRemove: Array<string>;
+}

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

@@ -0,0 +1,29 @@
+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;
+}

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/ManagedContentTranslationV2Representation.d.ts

@@ -0,0 +1,74 @@
+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 = "52e643b998d6763482c6d74542b38408";
+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 ManagedContentTranslationV2RepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialManagedContentTranslationV2RepresentationNormalizedKeyMetadata = 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): ManagedContentTranslationV2RepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ManagedContentTranslationV2Representation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ManagedContentTranslationV2Representation): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function normalize(input: ManagedContentTranslationV2Representation, existing: ManagedContentTranslationV2RepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTranslationV2RepresentationNormalized;
+export declare const select: () => $64$luvio_engine_BaseFragment;
+export declare function equals(existing: ManagedContentTranslationV2RepresentationNormalized, incoming: ManagedContentTranslationV2RepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTranslationV2Representation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Information about a managed content translation job
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTranslationV2RepresentationNormalized {
+    /** 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 | null;
+    /** 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 | null;
+    /** 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 | null;
+    /** The start date of a managed content translation job */
+    startDate: string | null;
+    /** The status of a managed content translation job */
+    status: string;
+}
+/**
+ * Information about a managed content translation job
+ *
+ * Keys:
+ *    id (string): id
+ */
+export interface ManagedContentTranslationV2Representation {
+    createdBy: string;
+    createdDate: string;
+    errorBodyUrl: string | null;
+    id: string;
+    inputBodyUrl: string | null;
+    jobType: string;
+    lastModifiedBy: string;
+    lastModifiedDate: string;
+    lastStatusUpdateDate: string;
+    name: string;
+    outputBodyUrl: string | null;
+    startDate: string | null;
+    status: string;
+}

package/dist/es/es2018/types/src/generated/types/ManagedContentTranslationV2RequestInputRep.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 = "fe17befe76b9bf4d597b7b36c2c06f78";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTranslationV2RequestInputRep, existing: ManagedContentTranslationV2RequestInputRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTranslationV2RequestInputRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTranslationV2RequestInputRepNormalized, incoming: ManagedContentTranslationV2RequestInputRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTranslationV2RequestInputRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input representation of a translation V2 request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationV2RequestInputRepNormalized {
+    /** Collection of managed Content folder Ids */
+    folderIds: Array<string>;
+    /** Indicates the managed content body id of the translation */
+    managedContentBodyId: string;
+    /** Collection of managedContentVariantIds Ids */
+    managedContentVariantIds: Array<string>;
+    /** Indicates the name of the translation */
+    name: string;
+    /** Parent FolderId of Managed Content Export data */
+    parentFolderId: string;
+    /** Indicates the source language for the authoring space */
+    sourceLanguage: string;
+    /** Indicates the target languages for the export action */
+    targetLanguages: Array<string>;
+    /** Indicates the type of the translation */
+    type: string;
+}
+/**
+ * Input representation of a translation V2 request
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationV2RequestInputRep {
+    folderIds: Array<string>;
+    managedContentBodyId: string;
+    managedContentVariantIds: Array<string>;
+    name: string;
+    parentFolderId: string;
+    sourceLanguage: string;
+    targetLanguages: Array<string>;
+    type: string;
+}

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

@@ -0,0 +1,28 @@
+import { ManagedContentTranslationV2RequestInputRep as ManagedContentTranslationV2RequestInputRep_ManagedContentTranslationV2RequestInputRep } from './ManagedContentTranslationV2RequestInputRep';
+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 = "2cdbb3c7c312e23899614be7423b5a2e";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTranslationV2RequestInputWrapperRep, existing: ManagedContentTranslationV2RequestInputWrapperRepNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTranslationV2RequestInputWrapperRepNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTranslationV2RequestInputWrapperRepNormalized, incoming: ManagedContentTranslationV2RequestInputWrapperRepNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTranslationV2RequestInputWrapperRep, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Wrapper for Input required for translation V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationV2RequestInputWrapperRepNormalized {
+    translationV2Request: ManagedContentTranslationV2RequestInputRep_ManagedContentTranslationV2RequestInputRep;
+}
+/**
+ * Wrapper for Input required for translation V2 job
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTranslationV2RequestInputWrapperRep {
+    translationV2Request: ManagedContentTranslationV2RequestInputRep_ManagedContentTranslationV2RequestInputRep;
+}

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/ManagedContentTypeSchemaRepresentation.d.ts

@@ -0,0 +1,48 @@
+import { ManagedContentTypeViewRepresentation as ManagedContentTypeViewRepresentation_ManagedContentTypeViewRepresentation } from './ManagedContentTypeViewRepresentation';
+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 = "ebb7a71a42ccb54db7dda65836b9be69";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSchemaRepresentation, existing: ManagedContentTypeSchemaRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSchemaRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSchemaRepresentationNormalized, incoming: ManagedContentTypeSchemaRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSchemaRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Representation of the ManagedContentType based on schema and associated views.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSchemaRepresentationNormalized {
+    /** Text description for the ManagedContentType */
+    description: string;
+    /** Developer Name of the ManagedContentType */
+    developerName: string;
+    /** Display name of the ManagedContentType */
+    label: string;
+    /** Namespace prefix for the ManagedContentType */
+    namespacePrefix: string;
+    /** JSON Schema representation of the ManagedContentType */
+    schema: {
+        [key: string]: {};
+    };
+    /** Views Representing the ManagedContentType */
+    views: Array<ManagedContentTypeViewRepresentation_ManagedContentTypeViewRepresentation>;
+}
+/**
+ * Representation of the ManagedContentType based on schema and associated views.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSchemaRepresentation {
+    description: string;
+    developerName: string;
+    label: string;
+    namespacePrefix: string;
+    schema: {
+        [key: string]: {};
+    };
+    views: Array<ManagedContentTypeViewRepresentation_ManagedContentTypeViewRepresentation>;
+}

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/ManagedContentTypeSummaryCollectionRepresentation.d.ts

@@ -0,0 +1,33 @@
+import { ManagedContentTypeSummaryRepresentation as ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation } from './ManagedContentTypeSummaryRepresentation';
+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 TTL = 120000;
+export declare const VERSION = "a722ea476134ec8addd2229742816b17";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ManagedContentTypeSummaryCollectionRepresentation, existing: ManagedContentTypeSummaryCollectionRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ManagedContentTypeSummaryCollectionRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ManagedContentTypeSummaryCollectionRepresentationNormalized, incoming: ManagedContentTypeSummaryCollectionRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ManagedContentTypeSummaryCollectionRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Managed content type summary collection representation.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSummaryCollectionRepresentationNormalized {
+    /** Managed content types. */
+    contentTypes: Array<ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation>;
+    /** Total number of managed content types. */
+    totalItems: number;
+}
+/**
+ * Managed content type summary collection representation.
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ManagedContentTypeSummaryCollectionRepresentation {
+    contentTypes: Array<ManagedContentTypeSummaryRepresentation_ManagedContentTypeSummaryRepresentation>;
+    totalItems: number;
+}