@vidispine/vdt-js 22.4.0-pre.4 → 22.4.0-pre.6

package/dist/index.d.ts

@@ -0,0 +1,1182 @@
+import * as _vidispine_types from '@vidispine/types';
+import { KeyValuePairType, MetadataValueType, MetadataFieldValueType, MetadataGroupValueType, MetadataType, SimpleMetadataType, FacetType, SearchResultEntryTimespanType, AudioComponentType, BinaryComponentType, FileType, TimeCodeType, ContainerComponentType, TimeBaseType, VideoComponentType, ShapeType, ItemType, TranscodePresetType } from '@vidispine/types';
+
+/**
+ *
+ * @param keyValuePairTypes
+ * @returns
+ *
+ * @category Other
+ */
+declare const parseKeyValuePairTypes: (keyValuePairTypes: KeyValuePairType[]) => {
+    [k: string]: string;
+};
+
+/**
+ * Object with all name of roles in VidiCore
+ *
+ * @category Auth
+ */
+declare const ROLE_NAMES: {
+    readonly ACCESSCONTROL_READ: "_accesscontrol_read";
+    readonly ACCESSCONTROL_WRITE: "_accesscontrol_write";
+    readonly ADMINISTRATOR: "_administrator";
+    readonly AUTO_PROJECTION_READ: "_auto_projection_read";
+    readonly AUTO_PROJECTION_WRITE: "_auto_projection_write";
+    readonly COLLECTION_NOTIFICATION_READ: "_collection_notification_read";
+    readonly COLLECTION_NOTIFICATION_WRITE: "_collection_notification_write";
+    readonly COLLECTION_READ: "_collection_read";
+    readonly COLLECTION_WRITE: "_collection_write";
+    readonly CONFIGURATION_READ: "_configuration_read";
+    readonly DELETION_LOCK_NOTIFICATION_READ: "_deletion_lock_notification_read";
+    readonly DELETION_LOCK_NOTIFICATION_WRITE: "_deletion_lock_notification_write";
+    readonly DELETION_LOCK_READ: "_deletion_lock_read";
+    readonly DELETION_LOCK_WRITE: "_deletion_lock_write";
+    readonly DOCUMENT_NOTIFICATION_READ: "_document_notification_read";
+    readonly DOCUMENT_NOTIFICATION_WRITE: "_document_notification_write";
+    readonly DOCUMENT_READ: "_document_read";
+    readonly DOCUMENT_WRITE: "_document_write";
+    readonly ERROR_READ: "_error_read";
+    readonly ERROR_WRITE: "_error_write";
+    readonly EXPORT: "_export";
+    readonly EXPORT_TEMPLATE_READ: "_export_template_read";
+    readonly EXPORT_TEMPLATE_WRITE: "_export_template_write";
+    readonly EXTERNAL_ID_READ: "_external_id_read";
+    readonly EXTERNAL_ID_WRITE: "_external_id_write";
+    readonly FILE_NOTIFICATION_READ: "_file_notification_read";
+    readonly FILE_NOTIFICATION_WRITE: "_file_notification_write";
+    readonly FILE_READ: "_file_read";
+    readonly FILE_WRITE: "_file_write";
+    readonly GROUP_READ: "_group_read";
+    readonly GROUP_WRITE: "_group_write";
+    readonly IMPORT_WRITE: "_import";
+    readonly ITEM_ID_READ: "_item_id_read";
+    readonly ITEM_ID_WRITE: "_item_id_write";
+    readonly ITEM_NOTIFICATION_READ: "_item_notification_read";
+    readonly ITEM_NOTIFICATION_WRITE: "_item_notification_write";
+    readonly ITEM_WRITE: "_item_write";
+    readonly ITEM_SEARCH: "_item_search";
+    readonly ITEM_SHAPE_READ: "_item_shape_read";
+    readonly ITEM_SHAPE_WRITE: "_item_shape_write";
+    readonly ITEM_TIMELINE_READ: "_item_timeline_read";
+    readonly ITEM_TIMELINE_WRITE: "_item_timeline_write";
+    readonly ITEM_URI: "_item_uri";
+    readonly JOB_NOTIFICATION_READ: "_job_notification_read";
+    readonly JOB_NOTIFICATION_WRITE: "_job_notification_write";
+    readonly JOB_READ: "_job_read";
+    readonly JOB_WRITE: "_job_write";
+    readonly LIBRARY_READ: "_library_read";
+    readonly LIBRARY_WRITE: "_library_write";
+    readonly LOCK_READ: "_lock_read";
+    readonly LOCK_WRITE: "_lock_write";
+    readonly LOG_READ: "_log_read";
+    readonly METADATA_DATASET_READ: "_metadata_dataset_read";
+    readonly METADATA_DATASET_WRITE: "_metadata_dataset_write";
+    readonly METADATA_FIELD_GROUP_READ: "_metadata_field_group_read";
+    readonly METADATA_FIELD_GROUP_WRITE: "_metadata_field_group_write";
+    readonly METADATA_FIELD_READ: "_metadata_field_read";
+    readonly METADATA_FIELD_WRITE: "_metadata_field_write";
+    readonly METADATA_GLOBAL_READ: "_metadata_global_read";
+    readonly METADATA_GLOBAL_WRITE: "_metadata_global_write";
+    readonly METADATA_LOCK_READ: "_metadata_lock_read";
+    readonly METADATA_LOCK_WRITE: "_metadata_lock_write";
+    readonly METADATA_READ: "_metadata_read";
+    readonly METADATA_SCHEMA_READ: "_metadata_schema_read";
+    readonly METADATA_SCHEMA_WRITE: "_metadata_schema_write";
+    readonly METADATA_WRITE: "_metadata_write";
+    readonly OTIF_ANALYZE: "_otif_analyze";
+    readonly OTIF_READ: "_otif_read";
+    readonly OTIF_WRITE: "_otif_write";
+    readonly PLACEHOLDER_NOTIFICATION_READ: "_placeholder_notification_read";
+    readonly PLACEHOLDER_NOTIFICATION_WRITE: "_placeholder_notification_write";
+    readonly PROJECTION_READ: "_projection_read";
+    readonly PROJECTION_WRITE: "_projection_write";
+    readonly QUOTA_NOTIFICATION_READ: "_quota_notification_read";
+    readonly QUOTA_NOTIFICATION_WRITE: "_quota_notification_write";
+    readonly QUOTA_READ: "_quota_read";
+    readonly QUOTA_WRITE: "_quota_write";
+    readonly RELATION_READ: "_relation_read";
+    readonly RELATION_WRITE: "_relation_write";
+    readonly RESOURCE_READ: "_resource_read";
+    readonly RESOURCE_WRITE: "_resource_write";
+    readonly RUN_AS: "_run_as";
+    readonly SEARCH: "_search";
+    readonly SEQUENCE_READ: "_sequence_read";
+    readonly SEQUENCE_WRITE: "_sequence_write";
+    readonly SHAPE_TAG_READ: "_shape_tag_read";
+    readonly SHAPE_TAG_WRITE: "_shape_tag_write";
+    readonly SITE_MANAGER: "_site_manager";
+    readonly SITE_RULE_READ: "_site_rule_read";
+    readonly SITE_RULE_WRITE: "_site_rule_write";
+    readonly STORAGE_GROUP_READ: "_storage_group_read";
+    readonly STORAGE_GROUP_WRITE: "_storage_group_write";
+    readonly STORAGE_NOTIFICATION_READ: "_storage_notification_read";
+    readonly STORAGE_NOTIFICATION_WRITE: "_storage_notification_write";
+    readonly STORAGE_READ: "_storage_read";
+    readonly STORAGE_RULE_READ: "_storage_rule_read";
+    readonly STORAGE_RULE_WRITE: "_storage_rule_write";
+    readonly STORAGE_WRITE: "_storage_write";
+    readonly SUPER_ACCESS_USER: "_super_access_user";
+    readonly TASKDEFINITION_READ: "_taskdefinition_read";
+    readonly TASKDEFINITION_WRITE: "_taskdefinition_write";
+    readonly THUMBNAIL_READ: "_thumbnail_read";
+    readonly THUMBNAIL_WRITE: "_thumbnail_write";
+    readonly TRANSCODER: "_transcoder";
+    readonly TRANSFER_READ: "_transfer_read";
+    readonly TRANSFER_WRITE: "_transfer_write";
+    readonly USER: "_user";
+    readonly VXA: "_vxa";
+    readonly VXA_READ: "_vxa_read";
+};
+
+declare type InputValueTypes = string | boolean | number | Date;
+/** Possible input values for the field value */
+declare type InputValue = InputValueTypes | InputValueTypes[];
+/** Input value object for the field value */
+declare type InputValueObject = {
+    value: string | InputValue;
+} & Omit<MetadataValueType, 'value'>;
+declare type InputFieldValue = InputValueObject | InputValue | InputValueObject[] | InputValue[];
+/** Input object to create field of */
+declare type InputFieldObject = {
+    value: InputFieldValue;
+} & MetadataFieldValueType;
+/** Input to create a field of */
+declare type InputField = InputFieldValue | InputFieldObject;
+/** Input to create one or multiple groups and/or fields of */
+declare type InputGroupsOrFields = InputGroup | InputGroup[] | InputField | InputField[];
+/** Input object to create group of */
+declare type InputGroup = {
+    [groupOrFieldName: string]: InputGroupsOrFields;
+} & Partial<MetadataGroupValueType>;
+/** Input to create a timespan of */
+declare type InputTimespan = {
+    start?: string | number;
+    end?: string | number;
+    base?: string;
+    [groupOrFieldName: string]: InputGroupsOrFields;
+};
+declare type CreateMetadataTypeInput = InputTimespan | InputTimespan[];
+/**
+ * Create a VidiCore metadata object from a more dense/simplified structure
+ *
+ * @param input To create VidiCore metadata object of
+ * @returns A VidiCore metadata object
+ *
+ * @category Metadata
+ */
+declare const createMetadataType: (input: CreateMetadataTypeInput) => MetadataType;
+
+declare type ParsedValueAttributes = Partial<Omit<MetadataValueType, 'value'>>;
+declare type ParsedValue<TOptions> = TOptions extends {
+    includeValueAttributes?: false;
+} ? string : {
+    value: string;
+} & ParsedValueAttributes;
+declare type ParseValueOptions = {
+    includeValueAttributes?: boolean | (keyof ParsedValueAttributes)[];
+};
+
+declare type ParsedValueList<TOptions> = TOptions extends {
+    joinValue?: string;
+    includeValueAttributes?: false;
+} ? string : TOptions extends {
+    arrayOnSingleValue?: true;
+} ? ParsedValue<TOptions>[] : ParsedValue<TOptions> | ParsedValue<TOptions>[];
+declare type ParseValueListOptions = {
+    joinValue?: string;
+    arrayOnSingleValue?: boolean;
+} & ParseValueOptions;
+
+declare type ParsedFieldAttributes = Partial<Omit<MetadataFieldValueType, 'value'>>;
+declare type ParsedFieldObject<TOptions> = {
+    value: ParsedValueList<TOptions>;
+} & ParsedFieldAttributes;
+declare type ParsedField<TOptions> = TOptions extends {
+    includeFieldAttributes?: false;
+} ? ParsedValueList<TOptions> : ParsedFieldObject<TOptions>;
+declare type ParseFieldOptions = {
+    includeFieldAttributes?: boolean | (keyof ParsedFieldAttributes)[];
+} & ParseValueListOptions;
+
+declare type ParseFieldListOptions = {
+    fieldAsList?: boolean;
+    arrayOnSingleField?: boolean;
+    overrideField?: boolean;
+} & ParseFieldOptions;
+declare type ParsedFieldList<TOptions> = TOptions extends {
+    fieldAsList?: true;
+} ? ParsedField<TOptions>[] : TOptions extends {
+    arrayOnSingle?: true;
+    arrayOnSingleField?: undefined | true;
+} | {
+    arrayOnSingleField?: true;
+} ? {
+    [name: string]: ParsedField<TOptions>[];
+} : TOptions extends {
+    flat?: true;
+    overrideField?: true | undefined;
+} | {
+    overrideField?: true;
+} ? {
+    [name: string]: ParsedField<TOptions>;
+} : {
+    [name: string]: ParsedField<TOptions> | ParsedField<TOptions>[];
+};
+/**
+ * Parse a metadata field list according to selected options
+ *
+ * @remarks
+ * Duplicate fields (same field name in the same field list) are usually not the data model we'd advise using.
+ * Since VidiCore supports multiple values in one fields, it's typically advised to store them as such.
+ * But, given duplicated fields when parsing it will:
+ * - with default options, merge duplicated field values to one field value array
+ * - with `fieldAsList` enabled, separate fields in the list/array (as usual, even if not duplicate)
+ * - with `includeFieldAttributes` enabled, return an array of field objects
+ * - with `overrideField` enabled - Override so it returns the latest "duplicated" field it parses
+ *
+ * @param fieldList Field list to parse
+ * @param [options=defaultOptions] Options for how to parse the field list
+ * @returns A parsed field list
+ *
+ * @category Metadata
+ */
+declare const parseFieldList: <TOptions extends ParseFieldListOptions = ParseFieldListOptions>(fieldList: MetadataFieldValueType[], options?: TOptions) => ParsedFieldList<TOptions>;
+
+declare type ParsedGroupAttributes = Omit<MetadataGroupValueType, 'field' | 'group'>;
+declare type ParseGroupOptions = {
+    includeGroupAttributes?: boolean | (keyof ParsedGroupAttributes)[];
+    groupAsList?: boolean;
+    arrayOnSingleGroup?: boolean;
+    overrideGroup?: boolean;
+} & ParseFieldListOptions;
+declare type ParsedGroup<TOptions> = ((TOptions extends {
+    groupAsList?: true;
+} ? {
+    group?: ParsedGroupList<TOptions>;
+} : {
+    [name: string]: ParsedGroupList<TOptions>;
+}) & (TOptions extends {
+    fieldAsList?: true;
+} ? {
+    field?: ParsedFieldList<TOptions>;
+} : {
+    [name: string]: ParsedFieldList<TOptions>;
+})) & ParsedGroupAttributes;
+declare type ParseGroupListOptions = ParseGroupOptions;
+declare type ParsedGroupList<TOptions> = TOptions extends {
+    groupAsList?: true;
+} ? ParsedGroup<TOptions>[] : TOptions extends {
+    arrayOnSingle?: true;
+    arrayOnSingleGroup?: true | undefined;
+} | {
+    arrayOnSingleGroup?: true;
+} ? {
+    [groupName: string]: ParsedGroup<TOptions>[];
+} : TOptions extends {
+    flat?: true;
+    overrideGroup?: true | undefined;
+} | {
+    overrideGroup?: true;
+} ? {
+    [groupName: string]: ParsedGroup<TOptions>;
+} : {
+    [groupName: string]: ParsedGroup<TOptions> | ParsedGroup<TOptions>[];
+};
+/**
+ * Parse a metadata group list according to selected options
+ *
+ * @remarks
+ * Parsing duplicate groups (with identical name) in the same group list will return:
+ * - with default options, an array of group objects
+ * - with `groupAsList` enabled, separate group objects in the list/array (as usual, even if not duplicate)
+ * - with `overrideGroup` enabled, return the latest duplicated group it parses
+ *
+ * @param groupList Group list to parse
+ * @param options options for how to parse list
+ * @returns A parsed group list
+ *
+ * @category Metadata
+ */
+declare const parseGroupList: <TOptions extends ParseGroupOptions = ParseGroupOptions>(groupList: MetadataGroupValueType[], options?: TOptions) => ParsedGroupList<TOptions>;
+
+declare type ParsedTimespanAttributes = Omit<MetadataType['timespan'][number], 'field' | 'group'>;
+/**
+ * __includeTimespanAttributes__:
+ * Include attributes on timespan
+ * (Set `true` or "array of attribute keys" to include specific attributes)
+ *
+ * __arrayOnSingle__:
+ * Return groups, fields and values as array if single
+ *
+ * __flat__:
+ * Return a flat (no array) representation of the timespan (Note: fields/groups might be overridden)
+ *
+ * @defaultValue `{ includeTimespanAttributes: false, arrayOnSingle: true, flat: false }`
+ */
+declare type ParseTimespanOptions = {
+    includeTimespanAttributes?: boolean | (keyof ParsedTimespanAttributes)[];
+    arrayOnSingle?: boolean;
+    flat?: boolean;
+} & ParseGroupListOptions;
+declare type ParsedTimespan<TOptions> = ((TOptions extends {
+    groupAsList?: true;
+} ? {
+    group?: ParsedGroupList<TOptions>;
+} : {
+    [name: string]: ParsedGroupList<TOptions>;
+}) & (TOptions extends {
+    fieldAsList?: true;
+} ? {
+    field?: ParsedFieldList<TOptions>;
+} : {
+    [name: string]: ParsedFieldList<TOptions>;
+})) & ParsedTimespanAttributes;
+/**
+ *
+ * Parses timespan according to specified options
+ *
+ * @remarks
+ * To ensure a flat (no array) representation when using `flat: true`, the parser will also set `overrideGroup` and `overrideField` to true (unless those are explicitly set false)
+ *
+ * @param timespan - A VidiCore metadata timespan
+ * @param options - Options to change how it is parsed
+ * @returns Timespan parsed according to options
+ *
+ * @see {@link parseGroupList} and {@link parseFieldList} for more info
+ *
+ * @category Metadata
+ */
+declare const parseTimespan: <TOptions extends ParseTimespanOptions = ParseTimespanOptions>(timespan: MetadataType['timespan'][number], options?: TOptions) => ParsedTimespan<TOptions>;
+
+declare type ParsedTimespanList<TOptions> = TOptions extends {
+    timespanAsList?: true;
+} ? ParsedTimespan<TOptions>[] : TOptions extends {
+    flat?: true;
+    onlyGeneric?: true | undefined;
+} | {
+    onlyGeneric?: true;
+} ? ParsedTimespan<TOptions> : {
+    [timespanKey: string]: ParsedTimespan<TOptions>[];
+};
+declare type ParseTimespanListOptions = {
+    timespanAsList?: boolean;
+    joinTimespan?: string;
+    sortTimespan?: boolean;
+    flat?: boolean;
+    flatTimespan?: boolean;
+} & ParseTimespanOptions;
+/**
+ * Parses timespanList according to specified options.
+ * The attributes can be targeted for each sub-type.
+ *
+ * @param timespanList - A Vidicore metadata timespan list
+ * @param options - Options which change how the metadataType is parsed.
+ * @returns Timespan list parsed according to options
+ *
+ * @see {@link parseTimespan} for more info
+ *
+ * @category Metadata
+ */
+declare const parseTimespanList: <TOptions extends ParseTimespanListOptions = ParseTimespanListOptions>(timespanList: MetadataType['timespan'], options?: TOptions) => ParsedTimespanList<TOptions>;
+
+declare type ParsedMetadataAttributes = Partial<Omit<MetadataType, 'timespan' | 'revision'> & {
+    revision?: string[];
+}>;
+declare type ParsedMetadataType<TOptions> = (TOptions extends {
+    timespanAsList?: true;
+} ? {
+    timespan: ParsedTimespanList<TOptions>;
+} : TOptions extends {
+    flat?: true;
+} ? ParsedTimespanList<TOptions> : {
+    [timespanKey: string]: ParsedTimespanList<TOptions>;
+}) & (TOptions extends {
+    includeMetadataAttributes?: true | string[];
+} ? ParsedMetadataAttributes : {});
+declare type ParseMetadataTypeOptions = {
+    includeMetadataAttributes?: boolean | (keyof ParsedMetadataAttributes)[];
+    flat?: boolean;
+} & ParseTimespanListOptions;
+/**
+ * Parses MetadataType according to specified options
+ *
+ * @remarks
+ * Be aware that you need to take into account that the returned groups and fields can be an array if it has multiple values or groups/fields with same name.
+ * If you are certain your metadata type won't return multiple groups/fields/values with same name or don't mind that they _might_ be overridden:
+ * you can use the option `flat` along with `joinValue` or `arrayOnSingleValue: false`.
+ *
+ * @param metadataType - A MetadataType from VidiCore
+ * @param options - Options which change how the metadataType is parsed
+ * @returns Metadata object parsed according to options
+ *
+ * @see {@link parseTimespanList} for more info
+ *
+ * @category Metadata
+ */
+declare function parseMetadataType<TOptions extends ParseMetadataTypeOptions = ParseMetadataTypeOptions>(metadataType: MetadataType, options?: TOptions): ParsedMetadataType<TOptions>;
+
+/**
+ * Parse simple (key/value) metadata
+ *
+ * Not indexed metadata, available on almost all entities (storages, library, user, group, etc...)
+ *
+ * @param simpleMetadataType A VidiCore simple metadata object
+ * @returns A parsed simple metadata object
+ *
+ * @category Metadata
+ */
+declare const parseSimpleMetadataType: (simpleMetadataType: SimpleMetadataType) => {
+    [key: string]: string;
+};
+
+declare type MetadataTypeToWebVttOptions = {
+    subtitleGroup?: string;
+    subtitleField?: string;
+};
+/**
+ * Convert metadata subtitle groups to WebVtt subtitles
+ *
+ * @param metadataType - Vidicore metadata object (should include subtitleGroup and subtitleField)
+ * @param options - options for how to map subtitle group
+ * @returns WebVtt subtitles
+ *
+ * @category Metadata
+ */
+declare const metadataTypeToWebVtt: (metadataType: MetadataType, options?: MetadataTypeToWebVttOptions) => string;
+
+/**
+ * Array with all available metadata group attributes
+ *
+ * @category Metadata
+ */
+declare const GROUP_ATTRIBUTE_KEYS: (keyof MetadataGroupValueType)[];
+/**
+ * Array with all available metadata group attributes
+ *
+ * @category Metadata
+ */
+declare const FIELD_ATTRIBUTE_KEYS: (keyof MetadataFieldValueType)[];
+/**
+ * Array with all available metadata field value attributes
+ *
+ * @category Metadata
+ */
+declare const FIELD_VALUE_ATTRIBUTE_KEYS: (keyof MetadataValueType)[];
+
+/**
+ * Array with all available VidiCore system/default field group names
+ *
+ * @category Metadata
+ */
+declare const SYSTEM_FIELDGROUPS: readonly ["stl_subtitle", "stl_tti", "stl_gsi", "mrk_marker", "pho_validation", "pho_resource", "pho_error", "facedetect_rect", "facedetect_face", "originalTrackFilename", "stl_gsiHeader"];
+/**
+ * Array with all available VidiCore system/default field group names
+ *
+ * @category Metadata
+ */
+declare const SYSTEM_FIELDS: readonly ["title", "user", "shapeTag", "representativeThumbnail", "representativeThumbnailNoAuth", "representativeItems", "itemId", "collectionId", "mediaType", "mimeType", "created", "startTimeCode", "startSeconds", "fieldValidationError", "schemaValidationError", "originalFilename", "originalUri", "originalAudioCodec", "originalVideoCodec", "originalHeight", "originalWidth", "originalFormat", "durationSeconds", "durationTimeCode", "solr-index", "__user", "__collection", "__collection_size", "__ancestor_collection", "__ancestor_collection_size", "__shape", "__shape_size", "__shape_last_added", "__placeholder_shape_size", "__version", "__version_count", "__storage", "__storage_size", "__shapetag_{tag}_hash_{hash}", "__storage_{tag}", "__storage_{tag}_size", "__storagegroup", "__storagegroup_size", "__sequence", "__sequence_size", "__metadata_last_modified", "__external_id", "__deletion_lock_id", "__deletion_lock_expiry", "__child_collection", "__child_collection_size", "__parent_collection", "__parent_collection_size", "__items_size", "stl_text", "stl_justification", "stl_xrelative", "stl_yrelative", "stl_vertical", "stl_verticalbase", "stl_horizontalbase", "stl_sizerelative", "stl_color", "stl_outline", "stl_outlinecolor", "stl_outlinesize", "stl_font", "stl_service", "stl_tti", "stl_gsi", "cct", "tcd", "tcf", "oet", "cd", "mnc", "cpn", "dfc", "tcp", "tcs", "tet", "tnb", "tnd", "en", "co", "tng", "rd", "mnr", "dsc", "opt", "lc", "tpt", "tn", "slr", "tns", "rn", "pub", "dsn", "ecd", "mrk_zerolength", "mrk_text", "mrk_color", "pho_resource_name", "pho_error_level", "pho_error_code", "pho_error_description", "facedetect_rect_width", "facedetect_rect_height", "facedetect_rect_y", "facedetect_rect_x", "facedetect_pid", "facedetect_rect", "trackId", "eidr_actor", "eidr_alternateId", "eidr_countryOfOrigin", "eidr_director", "eidr_id", "eidr_referentType", "eidr_releaseDate", "eidr_resourceName", "eidr_status", "eidr_sync", "ttml_div", "ttml_root", "vxa_collection_id", "vxaId", "vxaLocalPath", "tco", "cs", "ebn", "tf", "cf", "sgn", "tci", "jc", "vp", "sn"];
+
+declare type CreateFacetTypeFieldList = string[];
+declare type CreateFacetTypeOptions = {
+    count: boolean;
+};
+/**
+ * Create a Vidicore facet list
+ *
+ * @param fieldList Input to create facet of
+ * @param options Options for creating the facet
+ * @returns A VidiCore facet list
+ *
+ * @category Search
+ */
+declare const createFacetType: (fieldList?: CreateFacetTypeFieldList, options?: Partial<CreateFacetTypeOptions>) => {
+    field: string;
+    name: string;
+    count: boolean;
+    exclude: CreateFacetTypeFieldList;
+}[];
+
+declare type ParsedFacetTypeCount = {
+    [fieldValue: string]: number;
+};
+/** Parsed facet type */
+declare type ParsedFacetType = {
+    [fieldName: string]: ParsedFacetTypeCount;
+};
+/**
+ * Parse a VidiCore facet type list
+ *
+ * @param facetType A facet type list to parse
+ * @returns A parsed facet type list
+ *
+ * @category Search
+ */
+declare const parseFacetType: (facetType?: FacetType[]) => ParsedFacetType;
+
+declare type ParseHighlightTimespanOptions = {
+    arrayOnSingle?: boolean;
+    timespanAsList?: boolean;
+    joinValue?: string;
+};
+declare type ParsedHighlightTimespan = {
+    start?: string;
+    end?: string;
+    [key: string]: string | string[];
+};
+/**
+ * Parses highlight timespan in VidiCore into key/value object.
+ * The attributes can be targeted for each sub-type.
+ * @param timespan - A VidiCore search timespan
+ * @param options - Options which change how the timespans are parsed
+ *
+ * @category Search
+ */
+declare const parseHighlightTimespan: (timespan: SearchResultEntryTimespanType, options: ParseHighlightTimespanOptions) => ParsedHighlightTimespan;
+
+declare type ParseHighlightTimespanListOptions = {
+    timespanAsList?: boolean;
+    joinTimespan?: string;
+    flat?: boolean;
+    flatTimespan?: boolean;
+} & ParseHighlightTimespanOptions;
+/**
+ * Parses highlight timespans from VidiCore into key/value object.
+ * The attributes can be targeted for each sub-type.
+ *
+ * @param highlightTimespanList - A list of timespans from VidiCore.
+ * @param options - Options to change how the timespans are parsed
+ *
+ * @category Search
+ */
+declare const parseHighlightTimespanList: (highlightTimespanList?: SearchResultEntryTimespanType[], options?: ParseHighlightTimespanListOptions) => ParsedHighlightTimespan | ParsedHighlightTimespan[];
+
+declare const parseNowDate: (value?: string) => Date;
+
+declare type ParsedBaseMediaInfoType = {
+    Bit_rate_mode?: string;
+    Source?: string;
+} & {
+    [key: string]: string;
+};
+declare type ParsedAudioMediaInfoType = ParsedBaseMediaInfoType;
+declare type ParsedBinaryMediaInfoType = ParsedBaseMediaInfoType;
+declare type ParsedVideoMediaInfoType = ParsedBaseMediaInfoType & {
+    Format_Settings_GOP?: string;
+    intra_dc_precision?: string;
+};
+
+declare type ParsedAudioComponentType = {
+    audioFormat?: string;
+    audioCodec?: string;
+    audioSamplerate?: string;
+    audioSamplerateSamples?: number;
+    audioBitDepth?: string;
+    audioBitrate?: string;
+    audioBitRateMode?: string;
+    audioChannels?: number;
+    audioMetadata?: {
+        [key: string]: string;
+    };
+    audioMediaInfo?: ParsedAudioMediaInfoType;
+};
+/**
+ * Parses the technical information of a AudioComponentType.
+ * @param audioComponentType - A AudioComponentType from VidiCore.
+ * @returns Parsed component object.
+ *
+ * @category Shape
+ */
+declare const parseAudioComponent: (audioComponentType: AudioComponentType) => ParsedAudioComponentType;
+
+declare type ParsedBinaryComponentType = {
+    binaryMetadata?: {
+        [key: string]: string;
+    };
+    binaryMediaInfo?: ParsedBinaryMediaInfoType;
+};
+/**
+ * Parses the technical information of a BinaryComponentType.
+ * @param binaryComponentType - A BinaryComponentType from VidiCore.
+ * @returns Parsed component object.
+ *
+ * @category Shape
+ */
+declare const parseBinaryComponent: (binaryComponentType?: BinaryComponentType) => ParsedBinaryComponentType;
+
+declare type ParsedFileType = {
+    uri?: string;
+    hash?: string;
+    fileSize?: string;
+    fileSizeBytes?: number;
+    path?: string;
+    fileName?: string;
+    fileId?: string;
+};
+/**
+ * Parses a VidiCore file object
+ *
+ * @param fileType VidiCore file object
+ * @returns A parsed file object
+ *
+ * @category File
+ */
+declare const parseFileType: (fileType: FileType) => ParsedFileType;
+
+/**
+ * Parsed container component
+ */
+declare type ParsedContainerComponentType = {
+    containerFormat?: string;
+    videoFormat?: string;
+    audioFormat?: string;
+    textFormat?: string;
+    originalFilename?: string;
+    durationTimeCode?: TimeCodeType;
+    duration?: string;
+    startTimestamp?: TimeCodeType;
+    startTimecode?: TimeCodeType;
+    containerMetadata?: {
+        [key: string]: string;
+    };
+    containerMediaInfo?: ParsedBaseMediaInfoType;
+} & ParsedFileType;
+/**
+ * Parses the technical information of a ContainerComponentType.
+ * @param containerComponentType - A ContainerComponentType from VidiCore.
+ * @returns Parsed component object.
+ *
+ * @category Shape
+ */
+declare const parseContainerComponent: (containerComponentType?: ContainerComponentType) => ParsedContainerComponentType;
+
+declare type TimeBaseInput = {
+    numerator?: number | string;
+    denominator?: number | string;
+};
+/**
+ * TimeBase class representing the TimeBaseType in VidiCore
+ *
+ * For more info, see the [Time bases section in VidiCore API Docs](https://apidoc.vidispine.com/latest/time.html#time-bases)
+ *
+ * @category Time
+ */
+declare class TimeBase {
+    numerator: number;
+    denominator: number;
+    /**
+     * Constructor for TimeBase
+     *
+     * @param timeBaseType A TimeBaseType object
+     */
+    constructor(timeBaseType?: TimeBaseInput);
+    /**
+     * Get TimeBase in a constant representation (e.g. "PAL") if possible, otherwise undefined
+     * @returns Constant representation of the TimeBase
+     */
+    toConstant(): string;
+    /**
+     * Get TimeBase as a VidiCore TimeBaseType string
+     *
+     * @remarks
+     * Default format: denominator(:numerator if > 1)
+     * `constant` has precedence over `fraction` if both are true (e.g. NTSC > 30000:1001)
+     *
+     * @param options For how to display it as text
+     * @returns Text representation of the TimeBase
+     */
+    toText(options?: {
+        constant?: boolean;
+        fraction?: boolean;
+    }): string;
+    /**
+     * Output TimeBase as frame rate (by default max 16 decimal places)
+     *
+     * @remarks
+     * For `options.fixed`:
+     * - `true` gives two decimal places
+     * - `false` gives max amount of decimal places
+     * - `number` gives that amount of decimal places
+     *
+     * Default format: rate with two decimals if needed (i.e. decimals are > 0)
+     * Option precedence (when all true): `constant` > `rounded` > `fixed`
+     *
+     * @param options For how to display it as rate
+     *
+     * @return Rate of the TimeBase
+     *
+     * @category Time
+     */
+    toRate(options?: {
+        fixed?: boolean | number;
+        rounded?: boolean;
+    }): number;
+    /**
+     * Get TimeBase in a object representation
+     *
+     * @returns TimeBase as `{denominator, numerator}` object
+     */
+    toObject(): TimeBaseType;
+    /**
+     * @deprecated Use {@link TimeBase#toObject | toObject} instead
+     *
+     * @returns TimeBase as `{denominator, numerator}` object
+     */
+    toJson(): TimeBaseType;
+}
+
+/**
+ * Create a TimeBase Instance from a number, string or object representation of a time base
+ *
+ * @param timeBase Input to create time base from
+ * @returns A TimeBase instance
+ *
+ * @category Time
+ */
+declare const createTimeBase: (timeBase: TimeBaseInput | string | number) => TimeBase;
+
+/**
+ * Format a string representation of a time base to a TimeBase Instance
+ *
+ * @param timeBaseText The string to format to a TimeBase instance
+ * @returns A TimeBase Instance
+ *
+ * @category Time
+ */
+declare const formatTimeBaseText: (timeBaseText?: string | number) => TimeBase;
+
+/**
+ * Create a TimeBase instance of an object
+ *
+ * @param timeBase A TimeBase object
+ * @returns A TimeBase instance
+ *
+ * @category Time
+ */
+declare const formatTimeBaseType: (timeBase: TimeBaseInput) => TimeBase;
+
+declare type TimeCodeInput = {
+    samples?: number | string;
+    timeBase?: string | TimeBaseInput | TimeBase;
+};
+declare type TimeCodeInputOptions = {
+    dropFrame?: boolean;
+    frameSeparator?: string;
+};
+/**
+ * TimeCode class representing the TimeCodeType in VidiCore
+ *
+ * For more info, see the [Time Codes section of VidiCore API Docs](https://apidoc.vidispine.com/latest/time.html#time-codes)
+ *
+ * @category Time
+ */
+declare class TimeCode {
+    samples: number;
+    timeBase: TimeBase;
+    dropFrame?: boolean;
+    frameSeparator?: string;
+    /**
+     * Constructor for TimeCode
+     *
+     * @param timeCodeType Object to create TimeCode of
+     * @param options Options for the timeCode
+     */
+    constructor(timeCodeType: TimeCodeInput, options?: TimeCodeInputOptions);
+    /**
+     * Return this TimeCode added with the supplied timeCodeType
+     * If time bases differ, it will retain the time base of this TimeCode instance
+     * If supplied time code has a more granular time base - it will round down exceeding samples (hasn't reached that sample yet)
+     *
+     * Note: This might make you "lose" frames depending on granularity of time bases, e.g.
+     * "51@50".add("25@25") => "101@50"
+     * while "25@25".add("51@50") => "50@25" (not "101@50")
+     *
+     * @param timeCode A TimeCode instance you want to add with
+     * @returns A new TimeCode instance with the addition applied
+     */
+    add(timeCode: TimeCode): TimeCode;
+    /**
+     * Return this TimeCode subtracted with the supplied timeCodeType
+     * If time bases differ, it will retain the time base of the instance time code
+     * If supplied time code has a more granular time base - it will round down exceeding samples (hasn't reached that sample yet)
+     *
+     * Note: This might make you "lose" frames depending on granularity of time bases, e.g.
+     * "101@50".subtract("25@25") => "51@50"
+     * while "50@25".subtract("51@50") => "25@25" (not "49@50")
+     *
+     * @param timeCode A TimeCode instance you want to subtract with
+     * @returns A new TimeCode instance with the subtraction applied
+     */
+    subtract(timeCode: TimeCode): TimeCode;
+    /**
+     * Creates a new TimeCode instance with specified timeBase and samples adjusted to that.
+     *
+     * If it conforms to a less granular time base - it will floor samples (hasn't reached that sample yet)
+     * - e.g. "51@50".conformTo("PAL") => "25@PAL" (not "26@PAL")
+     *
+     * @param timeBase The TimeBase it should conform the TimeCode to
+     * @returns A new TimeCode instance with the conformTo timeBase applied
+     */
+    conformTimeBase(timeBase: TimeCodeInput['timeBase']): TimeCode;
+    /**
+     * Get TimeCode as a text representation
+     *
+     * @remarks
+     * Default format: samples@denominator(:numerator if > 1)
+     * `constant` has precedence over `fraction` if both are true
+     *
+     * @param options Options for how to format text
+     * @returns Text representation of TimeCode
+     *
+     * @category Time
+     */
+    toText(options?: {
+        includeTimeBaseForSeconds?: boolean;
+        constant?: boolean;
+        fraction?: boolean;
+    }): string;
+    /**
+     *  Get TimeCode in a units object representation
+     *
+     * @returns Units (time and frames) for the time code
+     */
+    toUnits(): {
+        hours: number;
+        minutes: number;
+        seconds: number;
+        frames: number;
+    };
+    /**
+     * Get TimeCode in a time object representation
+     * "milliseconds" is rounded down, if you want another representation use "partialSeconds"
+     *
+     * @returns Time for the time code
+     */
+    toTime(): {
+        hours: number;
+        minutes: number;
+        seconds: number;
+        milliseconds: number;
+        partialSeconds: number;
+    };
+    /**
+     * Get TimeCode in a seconds representation
+     *
+     * @returns Total seconds for the time code
+     */
+    toSeconds(): number;
+    /**
+     * Get TimeCode in a duration representation
+     * The time unit char keys for the format string are:
+     * - "h" for hour
+     * - "m" for minute
+     * - "s" for seconds
+     * - "S" for milliseconds
+     * Any other char will be kept in the duration output string.
+     *
+     * Add consecutive chars for zero padding.
+     *
+     * By default it:
+     * - uses colon delimiter (e.g. for format "hhmmss")
+     * - shows "m:ss" or "h:mm:ss" if format is undefined
+     *
+     * @param options Options for how to display duration
+     * @returns Duration representation of the TimeCode
+     */
+    toDuration(options?: {
+        format?: string;
+    }): string;
+    /**
+     * Get TimeCode in a smpte representation
+     *
+     * @returns Smpte representation of the TimeCode
+     */
+    toSmpte(): string;
+    /**
+     * Get TimeCode as a VidiCore TimeCodeType object
+     *
+     * @returns  TimeCode as `{ samples, timeBase }`
+     */
+    toObject(): {
+        samples: number;
+        timeBase: _vidispine_types.RationalType;
+    };
+    /**
+     * @deprecated Use {@link TimeCode#toObject | toObject} instead
+     *
+     * @returns TimeCode as `{ samples, timeBase }`
+     */
+    toJson(): {
+        samples: number;
+        timeBase: _vidispine_types.RationalType;
+    };
+}
+
+declare type FormatTimeCodeSecondsOptions = {
+    timeBase?: number | string | TimeBaseInput;
+    useGCD?: boolean;
+} & TimeCodeInputOptions;
+/**
+ * Format seconds to TimeCode object
+ * Input time base is always 1:1 since it expects seconds as input
+ *
+ * Note: Max 15 digits accuracy (double precision float64), e.g.
+ * - 10^6 seconds can have 10^9 decimals (nanosecond) precision
+ * - 10^9 seconds can have 10^6 decimals (microsecond) precision
+ * - 10^12 seconds can have 10^3 decimals (millisecond) precision
+ *
+ * @param seconds With or without decimals ("." and "," are both interpreted as decimal)
+ * @param options Options for how to format the seconds to a TimeCode
+ * @returns A TimeCode instance
+ *
+ * @category Time
+ */
+declare const formatTimeCodeSeconds: (seconds: string | number, options?: FormatTimeCodeSecondsOptions) => TimeCode;
+
+declare type FormatTimeCodeSmpteOptions = {
+    timeBase?: number | string | TimeBaseInput;
+    exceedingMode?: 'add' | 'ignore' | 'error';
+    dropFrame?: boolean;
+    frameSeparator?: string;
+} & Omit<TimeCodeInputOptions, 'dropFrame' | ' frameSeparator'>;
+/**
+ * Format smpte text to a TimeCode Instance
+ *
+ * exceedingMode:
+ * - "overflow" exceeding values will be kept (e.g. PAL and 00:00:00:25 => 00:00:01:00)
+ * - "truncate" exceeding values will be truncated (e.g. PAL and 00:00:00:25 => 00:00:00:24)
+ * - "error" exceeding values will throw error (e.g. PAL and 00:00:00:25 => Error)
+ *
+ * @param smpte String representation of smpte
+ * @param options Options for creating the time code from smpte
+ * @returns TimeCode instance created from smpte string
+ *
+ * @category Time
+ */
+declare const formatTimeCodeSmpte: (smpte: string, options?: FormatTimeCodeSmpteOptions) => TimeCode;
+
+declare type FormatTimeCodeTextOptions = {
+    timeBase?: number | string | TimeBaseInput;
+} & TimeCodeInputOptions;
+/**
+ * Format text to a TimeCode instance
+ *
+ * @returns A TimeCode instance
+ *
+ * @category Time
+ */
+declare const formatTimeCodeText: (timeCodeText?: number | string, options?: FormatTimeCodeTextOptions) => TimeCode;
+
+declare type CreateTimeCodeOptions = TimeCodeInputOptions | FormatTimeCodeSmpteOptions | FormatTimeCodeSecondsOptions | FormatTimeCodeTextOptions;
+/**
+ * Create a TimeCode instance from smpte, seconds/samples, timeCode object or string
+ *
+ * @param timeCode Smpte, seconds/samples, timeCode object or string
+ * @param options For the format functions
+ * @returns A TimeCode instance
+ *
+ * @category Time
+ */
+declare const createTimeCode: (timeCode: TimeCodeInput | string | number, options?: CreateTimeCodeOptions) => TimeCode;
+
+/**
+ * Format an object to a TimeCode instance
+ *
+ * @param timeCode To create TimeCode instance of
+ * @param options For the TimeCode constructor
+ * @returns  A TimeCode instance
+ *
+ * @category Time
+ */
+declare const formatTimeCodeType: (timeCode: TimeCodeInput, options?: TimeCodeInputOptions) => TimeCode;
+
+declare type ParsedVideoComponentType = {
+    videoFormat?: string;
+    dimension?: string;
+    frameRate?: string | number;
+    height?: number;
+    width?: number;
+    timeBase?: TimeBase;
+    timeCode?: TimeCode;
+    videoCodec?: string;
+    smpte?: string;
+    videoBitrate?: string;
+    fieldOrder?: string;
+    colorSpace?: string;
+    chromaSubsampling?: string;
+    aspectRatio?: string;
+    colorPrimaries?: string;
+    videoMetadata?: {
+        [key: string]: string;
+    };
+    videoMediaInfo?: ParsedVideoMediaInfoType;
+};
+/**
+ * Parses the technical information of a VideoComponentType.
+ * @param {Object} videoComponentType - A VideoComponentType from VidiCore.
+ * @returns {Object} Parsed component object.
+ *
+ * @category Shape
+ */
+declare const parseVideoComponent: (videoComponentType?: VideoComponentType) => ParsedVideoComponentType;
+
+declare type ParsedShapeType = {
+    uri?: string;
+    tag?: string;
+    mimeType?: string;
+} & ParsedContainerComponentType & ParsedBinaryComponentType & ParsedAudioComponentType & ParsedVideoComponentType;
+/**
+ * Parses the technical information of a ShapeType and its various components.
+ *
+ * Will only parse the first videoComponent, audioComponent, binaryComponent in the corresponding array.
+ * To parse a selected component see:
+ * - {@link parseContainerComponent}
+ * - {@link parseVideoComponent}
+ * - {@link parseAudioComponent}
+ * - {@link parseBinaryComponent}
+ * @param shapeType - A ShapeType from VidiCore.
+ * @returns Parsed shape object.
+ *
+ * @category Shape
+ */
+declare const parseShapeType: (shapeType?: ShapeType) => ParsedShapeType;
+
+declare const DOCUMENT_TYPES: {
+    readonly PDF: "PDF";
+    readonly TEXT: "TEXT";
+    readonly MSWORD: "MSWORD";
+    readonly JSON: "JSON";
+    readonly XML: "XML";
+};
+declare type DocumentType = keyof typeof DOCUMENT_TYPES;
+/**
+ * Return a const for the document type of a shape (looks at mimeType)
+ *
+ * @param shape
+ * @returns The document type for a shape
+ *
+ * @category Shape
+ */
+declare const getDocumentType: (shape: {
+    mimeType?: string | string[];
+}) => DocumentType;
+
+declare type FilteredShapeListObject = {
+    src: string;
+    type: string;
+    shape: ParsedShapeType;
+    [key: string]: string | ParsedShapeType;
+};
+declare type FilterShapeSourceOption = {
+    sortPriority?: Function;
+    allowedMimeTypes?: string[];
+    allowedMethods?: string[];
+    sourceKey?: string;
+    mimeTypeKey?: string;
+    shapeKey?: string;
+};
+/**
+ * Filter a shape type list to get shapes that are playable in a browser
+ *
+ * @param itemType
+ * @param options
+ * @returns
+ *
+ * @category Shape
+ */
+declare const filterShapeSource: (itemType: ItemType, options: FilterShapeSourceOption) => FilteredShapeListObject[];
+
+declare const SHAPE_MEDIA_TYPES: {
+    readonly IMAGE: "IMAGE";
+    readonly AUDIO: "AUDIO";
+    readonly VIDEO: "VIDEO";
+    readonly DOCUMENT: "DOCUMENT";
+    readonly BINARY: "BINARY";
+};
+declare type ShapeMediaType = keyof typeof SHAPE_MEDIA_TYPES;
+/**
+ * Returns a const for which media type a shape has
+ *
+ * @param parsedShape
+ * @returns
+ *
+ * @category Shape
+ */
+declare const getShapeMediaType: (parsedShape: ParsedShapeType) => ShapeMediaType;
+
+/**
+ * Find the thumbnail uri in a VidiCore item object that's nearest a timeCode
+ *
+ * @remarks
+ * Time code is included in path of VidiCore thumbnail uris
+ *
+ * @param itemType A VidiCore item object
+ * @param timeCode A timeCode to find nearest thumbnail to
+ * @returns A URI of a thumbnail, `undefined` if item has no thumbnails
+ *
+ * @category Thumbnail
+ */
+declare const findNearestThumbnail: (itemType: ItemType, timeCode: TimeCode | TimeCodeInput) => string;
+
+/**
+ * TODO
+ */
+declare type ParsedMediaConvertTranscodePreset = {
+    description?: string;
+    containerFormat?: any;
+    videoFormat?: string;
+    height?: number;
+    width?: number;
+    dimension?: string;
+    aspectRatio?: string;
+    fieldOrder?: string;
+    videoBitrate?: number;
+    timeBase?: TimeBase;
+    frameRate?: string | number;
+    audioFormat?: string;
+    audioSamplerate?: string;
+    audioBitrate?: string;
+    audioBitRateMode?: string;
+};
+/**
+ * TODO
+ *
+ * @param mediaconvert
+ * @returns
+ *
+ * @category Transcode
+ */
+declare const parseMediaConvertPreset: (mediaconvert: TranscodePresetType['mediaconvert']) => ParsedMediaConvertTranscodePreset;
+
+/**
+ * TODO
+ */
+declare type ParsedTranscodePreset = {
+    description?: string;
+    containerFormat?: any;
+    videoFormat?: string;
+    height?: number;
+    width?: number;
+    dimension?: string;
+    aspectRatio?: string;
+    fieldOrder?: string;
+    videoBitrate?: number;
+    timeBase?: TimeBase;
+    frameRate?: string | number;
+    audioFormat?: string;
+    audioSamplerate?: string;
+    audioBitrate?: string;
+    audioBitRateMode?: string;
+    audioChannels?: number;
+};
+/**
+ * TODO
+ *
+ * @param transcodePresetType
+ * @returns
+ *
+ * @category Transcode
+ */
+declare const parseTranscodePreset: (transcodePresetType: TranscodePresetType) => ParsedTranscodePreset;
+
+export { CreateFacetTypeFieldList, CreateFacetTypeOptions, CreateMetadataTypeInput, CreateTimeCodeOptions, DocumentType, FIELD_ATTRIBUTE_KEYS, FIELD_VALUE_ATTRIBUTE_KEYS, FilterShapeSourceOption, FilteredShapeListObject, FormatTimeCodeSecondsOptions, FormatTimeCodeSmpteOptions, FormatTimeCodeTextOptions, GROUP_ATTRIBUTE_KEYS, InputField, InputFieldObject, InputFieldValue, InputGroup, InputGroupsOrFields, InputTimespan, InputValue, InputValueObject, InputValueTypes, MetadataTypeToWebVttOptions, ParseFieldListOptions, ParseFieldOptions, ParseGroupListOptions, ParseGroupOptions, ParseHighlightTimespanListOptions, ParseHighlightTimespanOptions, ParseMetadataTypeOptions, ParseTimespanListOptions, ParseTimespanOptions, ParseValueListOptions, ParseValueOptions, ParsedAudioComponentType, ParsedAudioMediaInfoType, ParsedBaseMediaInfoType, ParsedBinaryComponentType, ParsedBinaryMediaInfoType, ParsedContainerComponentType, ParsedFacetType, ParsedFacetTypeCount, ParsedField, ParsedFieldAttributes, ParsedFieldList, ParsedFieldObject, ParsedFileType, ParsedGroup, ParsedGroupAttributes, ParsedGroupList, ParsedHighlightTimespan, ParsedMediaConvertTranscodePreset, ParsedMetadataAttributes, ParsedMetadataType, ParsedShapeType, ParsedTimespan, ParsedTimespanAttributes, ParsedTimespanList, ParsedTranscodePreset, ParsedValue, ParsedValueAttributes, ParsedValueList, ParsedVideoComponentType, ParsedVideoMediaInfoType, ROLE_NAMES, SYSTEM_FIELDGROUPS, SYSTEM_FIELDS, ShapeMediaType, TimeBase, TimeBaseInput, TimeCode, TimeCodeInput, TimeCodeInputOptions, createFacetType, createMetadataType, createTimeBase, createTimeCode, filterShapeSource, findNearestThumbnail, formatTimeBaseText, formatTimeBaseType, formatTimeCodeSeconds, formatTimeCodeSmpte, formatTimeCodeText, formatTimeCodeType, getDocumentType, getShapeMediaType, metadataTypeToWebVtt, parseAudioComponent, parseBinaryComponent, parseContainerComponent, parseFacetType, parseFieldList, parseFileType, parseGroupList, parseHighlightTimespan, parseHighlightTimespanList, parseKeyValuePairTypes as parseKeyValuePairType, parseMediaConvertPreset, parseMetadataType, parseNowDate, parseShapeType, parseSimpleMetadataType, parseTimespan, parseTimespanList, parseTranscodePreset, parseVideoComponent };