@financial-times/cp-content-pipeline-schema 1.4.4 → 1.5.0

package/src/fixtures/clipSet.ts

@@ -0,0 +1,72 @@
+import { ClipSet as ClipSetType } from '../types/internal-content'
+
+export const ClipSet: ClipSetType = {
+  accessibility: {
+    captions: [
+      {
+        mediaType: 'text/vtt',
+        url: 'https://next-media-api.ft.com/captions/16862228218010.vtt',
+      },
+    ],
+    transcript:
+      '<p>Hydrogen is this magic molecule which is the lightest, the most energetic and the most abundant in the universe. ... </p>',
+  },
+  description:
+    "The global push for net zero carbon emissions is one of humanity's greatest challenges. ...",
+  displayTitle: 'Ukranians fight back',
+  contentWarning: ['graphic violence', 'animal cruelty'],
+  id: 'http://www.ft.com/thing/f17fe25b-cdea-4d5f-a6af-40e56e33e888',
+  members: [
+    {
+      format: 'standardInline',
+      id: 'https://api.ft.com/content/4d000e07-d679-4e3b-bd6d-afa3461243a8',
+      type: 'http://www.ft.com/ontology/content/Clip',
+      dataSource: [
+        {
+          audioCodec: 'mp3',
+          binaryUrl:
+            'https://next-media-api.ft.com/renditions/16868569859480/0x0.mp3',
+          duration: 1057,
+          mediaType: 'audio/mpeg',
+          pixelHeight: 720,
+          pixelWidth: 1280,
+          videoCodec: 'h264',
+        },
+      ],
+      poster: {
+        id: 'https://api.ft.com/content/2f730c3c-1fb2-4131-9697-c534fe1ee488',
+        type: 'http://www.ft.com/ontology/content/ImageSet',
+        description: 'Picture for video',
+        members: [],
+      },
+    },
+    {
+      format: 'mobile',
+      id: 'https://api.ft.com/content/b529ba2b-d424-4f85-a93f-8413636dac82',
+      type: 'http://www.ft.com/ontology/content/Clip',
+      dataSource: [
+        {
+          audioCodec: 'mp3',
+          binaryUrl:
+            'https://next-media-api.ft.com/renditions/16868569859480/0x0.mp3',
+          duration: 1057,
+          mediaType: 'audio/mpeg',
+          pixelHeight: 720,
+          pixelWidth: 1280,
+          videoCodec: 'h264',
+        },
+      ],
+      poster: {
+        id: 'https://api.ft.com/content/2f730c3c-1fb2-4131-9697-c534fe1ee488',
+        type: 'http://www.ft.com/ontology/content/ImageSet',
+        description: 'Picture for video',
+        members: [],
+      },
+    },
+  ],
+  noAudio: false,
+  publishedDate: '2023-06-14T03:59:47.543Z',
+  source: 'YouGov',
+  subtitle: 'Drone hits Moscow tower block',
+  type: 'http://www.ft.com/ontology/content/ClipSet',
+}

package/src/generated/index.ts

@@ -2,12 +2,13 @@ import type { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } f
 import type { Concept as ConceptModel } from '../model/Concept';
 import type { CapiResponse } from '../model/CapiResponse';
 import type { Image as ImageModel } from '../model/Image';
+import type { Clip as ClipModel } from '../model/Clip';
 import type { Picture as PictureModel } from '../model/Picture';
 import type { RichText as RichTextModel } from '../model/RichText';
 import type { Topper as TopperModel } from '../model/Topper';
 import type { ContentTree } from '@financial-times/content-tree';
 import type { ReferenceWithCAPIData } from '../resolvers/content-tree/references';
-import type { Video as VideoNode, RawImage as RawImageNode } from '../resolvers/content-tree/Workarounds';
+import type { Video as VideoNode, ClipSet as ClipSetNode, OldClip as OldClipNode, RawImage as RawImageNode } from '../resolvers/content-tree/Workarounds';
 import type { QueryContext } from '../';
 export type Maybe<T> = T | null;
 export type InputMaybe<T> = Maybe<T>;
@@ -27,6 +28,7 @@ export type Scalars = {
   Float: { input: number; output: number; }
   AccessLevel: { input: 'premium' | 'subscribed' | 'registered' | 'free'; output: 'premium' | 'subscribed' | 'registered' | 'free'; }
   CanBeSyndicated: { input: 'yes' | 'no' | 'verify' | 'withContributorPayment' | 'unknown'; output: 'yes' | 'no' | 'verify' | 'withContributorPayment' | 'unknown'; }
+  ClipFormat: { input: 'standard-inline' | 'mobile'; output: 'standard-inline' | 'mobile'; }
   ContentType: { input: 'Article' | 'Placeholder' | 'Video' | 'Audio' | 'LiveBlogPackage' | 'LiveBlogPost' | 'ContentPackage' | 'Content' | 'MediaResource'; output: 'Article' | 'Placeholder' | 'Video' | 'Audio' | 'LiveBlogPackage' | 'LiveBlogPost' | 'ContentPackage' | 'Content' | 'MediaResource'; }
   FollowButtonVariant: { input: 'standard' | 'inverse' | 'opinion' | 'alphaville' | 'monochrome' | 'inverse-monochrome'; output: 'standard' | 'inverse' | 'opinion' | 'alphaville' | 'monochrome' | 'inverse-monochrome'; }
   ImageFormat: { input: 'standard' | 'standard-inline' | 'desktop' | 'mobile' | 'wide' | 'square' | 'square-ftedit' | 'portrait' | 'landscape'; output: 'standard' | 'standard-inline' | 'desktop' | 'mobile' | 'wide' | 'square' | 'square-ftedit' | 'portrait' | 'landscape'; }
@@ -37,6 +39,11 @@ export type Scalars = {
   TopperBackgroundColour: { input: 'paper' | 'wheat' | 'white' | 'black' | 'claret' | 'oxford' | 'slate' | 'crimson' | 'sky' | 'matisse'; output: 'paper' | 'wheat' | 'white' | 'black' | 'claret' | 'oxford' | 'slate' | 'crimson' | 'sky' | 'matisse'; }
 };
 
+export type Accessibility = {
+  readonly captions?: Maybe<ReadonlyArray<Maybe<Caption>>>;
+  readonly transcript?: Maybe<Scalars['String']['output']>;
+};
+
 export type AltStandfirst = {
   readonly promotionalStandfirst?: Maybe<Scalars['String']['output']>;
 };
@@ -142,6 +149,49 @@ export type BrandedTopper = Topper & TopperWithBrand & TopperWithTheme & {
   readonly textShadow?: Maybe<Scalars['Boolean']['output']>;
 };
 
+export type Caption = {
+  readonly mediaType?: Maybe<Scalars['String']['output']>;
+  readonly url?: Maybe<Scalars['String']['output']>;
+};
+
+export type Clip = {
+  readonly dataSource: ReadonlyArray<ClipSource>;
+  readonly format?: Maybe<Scalars['ClipFormat']['output']>;
+  readonly id: Scalars['String']['output'];
+  readonly poster?: Maybe<Scalars['String']['output']>;
+  readonly type?: Maybe<Scalars['String']['output']>;
+};
+
+export type ClipSet = Reference & {
+  readonly accessibility?: Maybe<Accessibility>;
+  readonly autoplay?: Maybe<Scalars['Boolean']['output']>;
+  readonly caption?: Maybe<Scalars['String']['output']>;
+  readonly clips?: Maybe<ReadonlyArray<Maybe<Clip>>>;
+  readonly contentWarning?: Maybe<ReadonlyArray<Maybe<Scalars['String']['output']>>>;
+  readonly credits?: Maybe<Scalars['String']['output']>;
+  readonly dataLayout?: Maybe<Scalars['String']['output']>;
+  readonly description?: Maybe<Scalars['String']['output']>;
+  readonly displayTitle?: Maybe<Scalars['String']['output']>;
+  readonly id: Scalars['String']['output'];
+  readonly loop?: Maybe<Scalars['Boolean']['output']>;
+  readonly muted?: Maybe<Scalars['Boolean']['output']>;
+  readonly noAudio?: Maybe<Scalars['Boolean']['output']>;
+  readonly publishedDate?: Maybe<Scalars['String']['output']>;
+  readonly source?: Maybe<Scalars['String']['output']>;
+  readonly subtitle?: Maybe<Scalars['String']['output']>;
+  readonly type: Scalars['String']['output'];
+};
+
+export type ClipSource = {
+  readonly audioCodec?: Maybe<Scalars['String']['output']>;
+  readonly binaryUrl: Scalars['String']['output'];
+  readonly duration?: Maybe<Scalars['Int']['output']>;
+  readonly mediaType: Scalars['String']['output'];
+  readonly pixelHeight?: Maybe<Scalars['Int']['output']>;
+  readonly pixelWidth?: Maybe<Scalars['Int']['output']>;
+  readonly videoCodec?: Maybe<Scalars['String']['output']>;
+};
+
 export type Concept = {
   readonly apiUrl?: Maybe<Scalars['String']['output']>;
   readonly directType?: Maybe<Scalars['String']['output']>;
@@ -990,7 +1040,7 @@ export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = R
   Content: ( CapiResponse ) | ( CapiResponse ) | ( CapiResponse ) | ( CapiResponse ) | ( CapiResponse ) | ( CapiResponse ) | ( CapiResponse );
   Image: ( ImageDesktop ) | ( ImageLandscape ) | ( ImageMobile ) | ( ImagePortrait ) | ( ImageSquare ) | ( ImageSquareFtEdit ) | ( ImageStandard ) | ( ImageStandardInline ) | ( ImageWide );
   Picture: ( Omit<PictureFullBleed, 'fallbackImage' | 'images'> & { fallbackImage: RefType['Image'], images: ReadonlyArray<RefType['Image']> } ) | ( Omit<PictureInline, 'fallbackImage' | 'images'> & { fallbackImage: RefType['Image'], images: ReadonlyArray<RefType['Image']> } ) | ( Omit<PictureStandard, 'fallbackImage' | 'images'> & { fallbackImage: RefType['Image'], images: ReadonlyArray<RefType['Image']> } );
-  Reference: ( ReferenceWithCAPIData<ContentTree.Flourish> ) | ( ReferenceWithCAPIData<ContentTree.ImageSet> ) | ( ReferenceWithCAPIData<ContentTree.LayoutImage> ) | ( ReferenceWithCAPIData<ContentTree.ImageSet> ) | ( ReferenceWithCAPIData<RawImageNode> ) | ( ReferenceWithCAPIData<ContentTree.Recommended> ) | ( ReferenceWithCAPIData<ContentTree.ScrollyImage> ) | ( ReferenceWithCAPIData<ContentTree.Tweet> ) | ( ReferenceWithCAPIData<VideoNode> );
+  Reference: ( ReferenceWithCAPIData<ClipSetNode|OldClipNode> ) | ( ReferenceWithCAPIData<ContentTree.Flourish> ) | ( ReferenceWithCAPIData<ContentTree.ImageSet> ) | ( ReferenceWithCAPIData<ContentTree.LayoutImage> ) | ( ReferenceWithCAPIData<ContentTree.ImageSet> ) | ( ReferenceWithCAPIData<RawImageNode> ) | ( ReferenceWithCAPIData<ContentTree.Recommended> ) | ( ReferenceWithCAPIData<ContentTree.ScrollyImage> ) | ( ReferenceWithCAPIData<ContentTree.Tweet> ) | ( ReferenceWithCAPIData<VideoNode> );
   Topper: ( Omit<BasicTopper, 'displayConcept' | 'genreConcept' | 'intro'> & { displayConcept?: Maybe<RefType['Concept']>, genreConcept?: Maybe<RefType['Concept']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<BrandedTopper, 'brandConcept' | 'displayConcept' | 'genreConcept' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, genreConcept?: Maybe<RefType['Concept']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<DeepLandscapeTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<DeepPortraitTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<FullBleedTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( TopperModel ) | ( TopperModel ) | ( Omit<SplitTextTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } );
   TopperWithBrand: ( Omit<BrandedTopper, 'brandConcept' | 'displayConcept' | 'genreConcept' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, genreConcept?: Maybe<RefType['Concept']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<DeepLandscapeTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<DeepPortraitTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( Omit<FullBleedTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } ) | ( TopperModel ) | ( Omit<SplitTextTopper, 'brandConcept' | 'displayConcept' | 'fallbackImage' | 'genreConcept' | 'images' | 'intro'> & { brandConcept?: Maybe<RefType['Concept']>, displayConcept?: Maybe<RefType['Concept']>, fallbackImage?: Maybe<RefType['Image']>, genreConcept?: Maybe<RefType['Concept']>, images: ReadonlyArray<RefType['Image']>, intro?: Maybe<RefType['RichText']> } );
   TopperWithHeadshot: ( TopperModel ) | ( TopperModel );
@@ -1002,6 +1052,7 @@ export type ResolversInterfaceTypes<RefType extends Record<string, unknown>> = R
 /** Mapping between all available schema types and the resolvers types */
 export type ResolversTypes = ResolversObject<{
   AccessLevel: ResolverTypeWrapper<Scalars['AccessLevel']['output']>;
+  Accessibility: ResolverTypeWrapper<Accessibility>;
   AltStandfirst: ResolverTypeWrapper<AltStandfirst>;
   AltTitle: ResolverTypeWrapper<AltTitle>;
   Article: ResolverTypeWrapper<CapiResponse>;
@@ -1010,6 +1061,11 @@ export type ResolversTypes = ResolversObject<{
   Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
   BrandedTopper: ResolverTypeWrapper<Omit<BrandedTopper, 'brandConcept' | 'displayConcept' | 'genreConcept' | 'intro'> & { brandConcept?: Maybe<ResolversTypes['Concept']>, displayConcept?: Maybe<ResolversTypes['Concept']>, genreConcept?: Maybe<ResolversTypes['Concept']>, intro?: Maybe<ResolversTypes['RichText']> }>;
   CanBeSyndicated: ResolverTypeWrapper<Scalars['CanBeSyndicated']['output']>;
+  Caption: ResolverTypeWrapper<Caption>;
+  Clip: ResolverTypeWrapper<ClipModel>;
+  ClipFormat: ResolverTypeWrapper<Scalars['ClipFormat']['output']>;
+  ClipSet: ResolverTypeWrapper<ReferenceWithCAPIData<ClipSetNode|OldClipNode>>;
+  ClipSource: ResolverTypeWrapper<ClipSource>;
   Concept: ResolverTypeWrapper<ConceptModel>;
   Content: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Content']>;
   ContentPackage: ResolverTypeWrapper<CapiResponse>;
@@ -1081,6 +1137,7 @@ export type ResolversTypes = ResolversObject<{
 /** Mapping between all available schema types and the resolvers parents */
 export type ResolversParentTypes = ResolversObject<{
   AccessLevel: Scalars['AccessLevel']['output'];
+  Accessibility: Accessibility;
   AltStandfirst: AltStandfirst;
   AltTitle: AltTitle;
   Article: CapiResponse;
@@ -1089,6 +1146,11 @@ export type ResolversParentTypes = ResolversObject<{
   Boolean: Scalars['Boolean']['output'];
   BrandedTopper: Omit<BrandedTopper, 'brandConcept' | 'displayConcept' | 'genreConcept' | 'intro'> & { brandConcept?: Maybe<ResolversParentTypes['Concept']>, displayConcept?: Maybe<ResolversParentTypes['Concept']>, genreConcept?: Maybe<ResolversParentTypes['Concept']>, intro?: Maybe<ResolversParentTypes['RichText']> };
   CanBeSyndicated: Scalars['CanBeSyndicated']['output'];
+  Caption: Caption;
+  Clip: ClipModel;
+  ClipFormat: Scalars['ClipFormat']['output'];
+  ClipSet: ReferenceWithCAPIData<ClipSetNode|OldClipNode>;
+  ClipSource: ClipSource;
   Concept: ConceptModel;
   Content: ResolversInterfaceTypes<ResolversParentTypes>['Content'];
   ContentPackage: CapiResponse;
@@ -1161,6 +1223,12 @@ export interface AccessLevelScalarConfig extends GraphQLScalarTypeConfig<Resolve
   name: 'AccessLevel';
 }
 
+export type AccessibilityResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Accessibility'] = ResolversParentTypes['Accessibility']> = ResolversObject<{
+  captions?: Resolver<Maybe<ReadonlyArray<Maybe<ResolversTypes['Caption']>>>, ParentType, ContextType>;
+  transcript?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
 export type AltStandfirstResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['AltStandfirst'] = ResolversParentTypes['AltStandfirst']> = ResolversObject<{
   promotionalStandfirst?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
@@ -1254,6 +1322,57 @@ export interface CanBeSyndicatedScalarConfig extends GraphQLScalarTypeConfig<Res
   name: 'CanBeSyndicated';
 }
 
+export type CaptionResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Caption'] = ResolversParentTypes['Caption']> = ResolversObject<{
+  mediaType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  url?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type ClipResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Clip'] = ResolversParentTypes['Clip']> = ResolversObject<{
+  dataSource?: Resolver<ReadonlyArray<ResolversTypes['ClipSource']>, ParentType, ContextType>;
+  format?: Resolver<Maybe<ResolversTypes['ClipFormat']>, ParentType, ContextType>;
+  id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  poster?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  type?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export interface ClipFormatScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['ClipFormat'], any> {
+  name: 'ClipFormat';
+}
+
+export type ClipSetResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['ClipSet'] = ResolversParentTypes['ClipSet']> = ResolversObject<{
+  accessibility?: Resolver<Maybe<ResolversTypes['Accessibility']>, ParentType, ContextType>;
+  autoplay?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  caption?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  clips?: Resolver<Maybe<ReadonlyArray<Maybe<ResolversTypes['Clip']>>>, ParentType, ContextType>;
+  contentWarning?: Resolver<Maybe<ReadonlyArray<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+  credits?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  dataLayout?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  displayTitle?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  loop?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  muted?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  noAudio?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  publishedDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  source?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  subtitle?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type ClipSourceResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['ClipSource'] = ResolversParentTypes['ClipSource']> = ResolversObject<{
+  audioCodec?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  binaryUrl?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  duration?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+  mediaType?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  pixelHeight?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+  pixelWidth?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+  videoCodec?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
 export type ConceptResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Concept'] = ResolversParentTypes['Concept']> = ResolversObject<{
   apiUrl?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   directType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
@@ -1782,7 +1901,7 @@ export type RecommendedResolvers<ContextType = QueryContext, ParentType extends
 }>;
 
 export type ReferenceResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Reference'] = ResolversParentTypes['Reference']> = ResolversObject<{
-  __resolveType?: TypeResolveFn<'Flourish' | 'ImageSet' | 'LayoutImage' | 'MainImage' | 'RawImage' | 'Recommended' | 'ScrollyImage' | 'Tweet' | 'VideoReference', ParentType, ContextType>;
+  __resolveType?: TypeResolveFn<'ClipSet' | 'Flourish' | 'ImageSet' | 'LayoutImage' | 'MainImage' | 'RawImage' | 'Recommended' | 'ScrollyImage' | 'Tweet' | 'VideoReference', ParentType, ContextType>;
   type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 }>;
 
@@ -1936,6 +2055,7 @@ export type VideoReferenceResolvers<ContextType = QueryContext, ParentType exten
 
 export type Resolvers<ContextType = QueryContext> = ResolversObject<{
   AccessLevel?: GraphQLScalarType;
+  Accessibility?: AccessibilityResolvers<ContextType>;
   AltStandfirst?: AltStandfirstResolvers<ContextType>;
   AltTitle?: AltTitleResolvers<ContextType>;
   Article?: ArticleResolvers<ContextType>;
@@ -1943,6 +2063,11 @@ export type Resolvers<ContextType = QueryContext> = ResolversObject<{
   BasicTopper?: BasicTopperResolvers<ContextType>;
   BrandedTopper?: BrandedTopperResolvers<ContextType>;
   CanBeSyndicated?: GraphQLScalarType;
+  Caption?: CaptionResolvers<ContextType>;
+  Clip?: ClipResolvers<ContextType>;
+  ClipFormat?: GraphQLScalarType;
+  ClipSet?: ClipSetResolvers<ContextType>;
+  ClipSource?: ClipSourceResolvers<ContextType>;
   Concept?: ConceptResolvers<ContextType>;
   Content?: ContentResolvers<ContextType>;
   ContentPackage?: ContentPackageResolvers<ContextType>;

package/src/model/CapiResponse.ts

@@ -2,6 +2,7 @@ import type {
   ImageSet,
   ContentTypeSchemas,
   MainImage,
+  ClipSet,
 } from '../types/internal-content'
 import conceptIds from '@financial-times/n-concept-ids'
 import metadata from '@financial-times/n-display-metadata'
@@ -125,7 +126,7 @@ export class CapiResponse {
     /*
      * Check if the incoming data matches the types defined in our data source schema
      * Our data source schema should handle all possible response from CAPI
-     * As there is no agreed schema provided by CAPI there is a chance it will out of date / incorrect at times
+     * As there is no agreed schema provided by CAPI there is a chance it will be out of date / incorrect at times
      * Manual updates will be required at times to keep it in sync with the responses we receive
      */
     const schemaResponse = model.schema().safeParse(content)
@@ -177,7 +178,7 @@ export class CapiResponse {
     }
     return null
   }
-  embeds(): ImageSet[] {
+  embeds(): (ImageSet | ClipSet)[] {
     if ('embeds' in this.capiData && this.capiData.embeds)
       return this.capiData.embeds
     return []

package/src/model/Clip.ts

@@ -0,0 +1,75 @@
+import { uuidFromUrl } from '../helpers/metadata'
+import { Clip as ClipMetadata } from '../types/internal-content'
+import {
+  LiteralUnionScalarValues,
+  validLiteralUnionValue,
+} from '../resolvers/literal-union'
+import { ClipFormat } from '../resolvers/scalars'
+
+export type ClipSource = {
+  binaryUrl: string
+  mediaType: string
+  audioCodec?: string
+  duration?: number
+  pixelHeight?: number
+  pixelWidth?: number
+  videoCodec?: string
+}
+
+export interface ClipVideo {
+  id(): string
+  type(): string
+  format(): LiteralUnionScalarValues<typeof ClipFormat>
+  poster(): string
+  dataSource(): ClipSource[]
+}
+
+export class Clip implements ClipVideo {
+  constructor(private clip: ClipMetadata) {}
+
+  type() {
+    return 'clip'
+  }
+
+  id() {
+    const uuid = uuidFromUrl(this.clip.id)
+    if (!uuid) {
+      throw new Error(`${this.clip.id} is not a valid Content API Clip ID`)
+    }
+    return uuid
+  }
+
+  format(): LiteralUnionScalarValues<typeof ClipFormat> {
+    if (this.clip.format) {
+      const capiFormat = this.clip.format
+
+      if (capiFormat === 'standardInline') {
+        return 'standard-inline'
+      }
+
+      if (validLiteralUnionValue(this.clip.format, ClipFormat.values)) {
+        return capiFormat
+      }
+    }
+
+    return 'standard-inline'
+  }
+
+  dataSource() {
+    // Order clip dataSource to have an order of video formats first then audio/mpeg, as the browser will first check if it can play the MIME type of the first source
+    const dataSource = this.clip.dataSource.slice().sort((a, b) => {
+      if (a.mediaType === 'video/mp4' && b.mediaType !== 'video/mp4') {
+        return -1
+      }
+      if (a.mediaType !== 'video/mp4' && b.mediaType === 'video/mp4') {
+        return 1
+      }
+      return 0
+    })
+    return dataSource as ClipSource[]
+  }
+
+  poster() {
+    return this.clip.poster?.members[0].binaryUrl ?? ''
+  }
+}

package/src/model/__snapshots__/RichText.test.ts.snap

@@ -96,6 +96,20 @@ Object {
         "type": "image-set",
       },
     },
+    Object {
+      "contentApiData": undefined,
+      "reference": Object {
+        "autoplay": true,
+        "data": Object {
+          "referenceIndex": 9,
+        },
+        "dataLayout": "in-line",
+        "id": "http://api-t.ft.com/content/f17fe25b-cdea-4d5f-a6af-40e56e33e888",
+        "loop": true,
+        "muted": true,
+        "type": "clip-set",
+      },
+    },
   ],
   "text": "Eliot After The Waste Land (Eliot Biographies, 2)by Robert Crawford, Jonathan Cape £25
 
@@ -905,6 +919,17 @@ Join our online book group on Facebook at FT Books Café",
         ],
         "type": "paragraph",
       },
+      Object {
+        "autoplay": true,
+        "data": Object {
+          "referenceIndex": 9,
+        },
+        "dataLayout": "in-line",
+        "id": "http://api-t.ft.com/content/f17fe25b-cdea-4d5f-a6af-40e56e33e888",
+        "loop": true,
+        "muted": true,
+        "type": "clip-set",
+      },
       Object {
         "children": Array [
           Object {

package/src/model/schemas/capi/base-schema.ts

@@ -88,6 +88,50 @@ export const AlternativeImage = z.object({
   promotionalImage: BaseImage,
 })
 
+const ClipSource = z.object({
+  audioCodec: z.string().optional(),
+  binaryUrl: z.string().optional(),
+  duration: z.number().optional(),
+  mediaType: z.string().optional(),
+  pixelHeight: z.number().optional(),
+  pixelWidth: z.number().optional(),
+  videoCodec: z.string().optional(),
+})
+
+export const Clip = z.object({
+  id: z.string(),
+  type: z.literal('http://www.ft.com/ontology/content/Clip'),
+  format: z
+    .union([z.literal('standardInline'), z.literal('mobile')])
+    .optional(),
+  dataSource: ClipSource.array(),
+  poster: ImageSet.optional(),
+})
+
+export const ClipSet = z.object({
+  id: z.string(),
+  type: z.literal('http://www.ft.com/ontology/content/ClipSet'),
+  members: Clip.array(),
+  caption: z.string().optional(),
+  dataCopyright: z.string().optional(),
+  description: z.string().optional(),
+  displayTitle: z.string().optional(),
+  contentWarning: z.string().array().optional(),
+  noAudio: z.boolean().optional(),
+  source: z.string().optional(),
+  subtitle: z.string().optional(),
+  publishedDate: z.string().optional(),
+  accessibility: z.object({
+    captions: z.array(
+      z.object({
+        mediaType: z.string(),
+        url: z.string(),
+      })
+    ),
+    transcript: z.string().optional(),
+  }),
+})
+
 export const DataSource = z.object({
   binaryUrl: z.string(),
   duration: z.number(),
@@ -213,6 +257,6 @@ export const baseMediaSchema = z.object({
   mainImage: MainImage.optional(),
   leadImages: LeadImage.array().optional(),
   alternativeImages: AlternativeImage.optional(),
-  embeds: ImageSet.array().optional(),
+  embeds: z.array(z.union([ImageSet, ClipSet])).optional(),
   dataSource: DataSource.array().optional(),
 })

package/src/resolvers/clip.ts

@@ -0,0 +1,13 @@
+import { ClipResolvers } from '../generated'
+
+const resolvers = {
+  Clip: {
+    __resolveType: () => 'Clip',
+    dataSource: (clip) => clip.dataSource(),
+    type: (clip) => clip.type(),
+    format: (clip) => clip.format(),
+    poster: (clip) => clip.poster(),
+  },
+} satisfies { Clip: ClipResolvers }
+
+export default resolvers

package/src/resolvers/content-tree/Workarounds.ts

@@ -68,7 +68,7 @@ export interface YoutubeVideo extends ContentTree.Node {
   url: string
 }
 
-export interface Clip extends ContentTree.Node {
+export interface OldClip extends ContentTree.Node {
   type: 'clip'
   url: string
   autoplay: boolean
@@ -83,6 +83,16 @@ export interface Clip extends ContentTree.Node {
   credits: string
 }
 
+// this type is used for bodyXML transformation ONLY in tagMappings
+export interface ClipSet extends ContentTree.Node {
+  type: 'clip-set'
+  id: string
+  autoplay: boolean
+  loop: boolean
+  muted: boolean
+  dataLayout: 'in-line' | 'mid-grid' | 'full-grid'
+}
+
 export type TableColumnSettings = {
   hideOnMobile: boolean
   sortable: boolean
@@ -148,6 +158,8 @@ export type AnyNode =
   | ContentTree.Blockquote
   | ContentTree.Pullquote
   | ContentTree.ImageSet
+  | ClipSet
+  | OldClip
   | ContentTree.Recommended
   | ContentTree.Tweet
   | ContentTree.Flourish
@@ -168,7 +180,6 @@ export type AnyNode =
   | TableCell
   | Video
   | YoutubeVideo
-  | Clip
   | MainImage
   | MainImageRaw
   | RawImage

package/src/resolvers/content-tree/references/ClipSet.ts

@@ -0,0 +1,49 @@
+import type { ClipSet as CAPIClipSet } from '../../../types/internal-content'
+import type { ClipSet as ClipSetWorkaroundContentTree, OldClip as OldClipContentTree } from '../Workarounds'
+import { uuidFromUrl } from '../../../helpers/metadata'
+import { Clip } from '../../../model/Clip'
+import { ClipSetResolvers } from '../../../generated'
+import { ReferenceWithCAPIData } from '.'
+
+function getClipSet(
+  parent: ReferenceWithCAPIData<ClipSetWorkaroundContentTree|OldClipContentTree>
+) {
+  const clipSets = parent.contentApiData
+    ?.embeds()
+    ?.filter((embedded) => embedded.type.includes('ClipSet')) as
+    | CAPIClipSet[]
+    | []
+
+  const clipSet = clipSets?.find(
+    (embed: CAPIClipSet) =>
+      uuidFromUrl(embed.id) === uuidFromUrl((parent.reference as ClipSetWorkaroundContentTree).id)
+  )
+
+  return clipSet as CAPIClipSet
+}
+
+export const ClipSet = {
+  // amend id, caption, description, credits when v1 is no longer supported
+  id: (parent) => ((parent.reference as ClipSetWorkaroundContentTree).id ? uuidFromUrl((parent.reference as ClipSetWorkaroundContentTree).id) : ''),
+  autoplay: (parent) => parent.reference.autoplay,
+  noAudio: (parent) => getClipSet(parent)?.noAudio || null,
+  loop: (parent) => parent.reference.loop,
+  muted: (parent) => parent.reference.muted,
+  dataLayout: (parent) => parent.reference.dataLayout,
+  caption: (parent) => ((parent.reference as OldClipContentTree).caption ?? getClipSet(parent)?.caption),
+  accessibility: (parent) => getClipSet(parent)?.accessibility || null,
+  description: (parent) => ((parent.reference as OldClipContentTree).description ?? getClipSet(parent)?.description),
+  credits: (parent) => ((parent.reference as OldClipContentTree).credits ??  getClipSet(parent)?.dataCopyright),
+  displayTitle: (parent) => getClipSet(parent)?.displayTitle || null,
+  contentWarning: (parent) => getClipSet(parent)?.contentWarning || null,
+  source: (parent) => getClipSet(parent)?.source || null,
+  subtitle: (parent) => getClipSet(parent)?.subtitle || null,
+  publishedDate: (parent) => getClipSet(parent)?.publishedDate || null,
+  async clips(parent) {
+    const clipSet = getClipSet(parent)
+
+    return clipSet && clipSet.members && clipSet.members.length > 0
+      ? clipSet.members.map((clip) => new Clip(clip))
+      : null
+  },
+} satisfies ClipSetResolvers

package/src/resolvers/content-tree/references/ImageSet.ts

@@ -7,12 +7,16 @@ export const ImageSet = {
   async picture(parent, _args, context) {
     const isLiveBlog = parent.contentApiData?.type() === 'LiveBlogPost'
 
-    const imageSet = parent.contentApiData
+    const imageSets = parent.contentApiData
       ?.embeds()
-      ?.find(
-        (embed: CAPIImageSet) =>
-          uuidFromUrl(embed.id) === uuidFromUrl(parent.reference.id)
-      )
+      ?.filter((embedded) => embedded.type.includes('ImageSet')) as
+      | CAPIImageSet[]
+      | []
+
+    const imageSet = imageSets?.find(
+      (embed: CAPIImageSet) =>
+        uuidFromUrl(embed.id) === uuidFromUrl(parent.reference.id)
+    )
 
     return imageSet && imageSet.members && imageSet.members.length > 0
       ? new Picture(imageSet, isLiveBlog, context)