Interface Complete

This cluster supports all ContentLauncher features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptHeader: Attribute<string[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                urlPlayback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
            dash: BitFlag;
            hls: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                urlPlayback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        advancedSeek: BitFlag;
        audioTracks: BitFlag;
        contentSearch: BitFlag;
        textTracks: BitFlag;
        urlPlayback: BitFlag;
    }>>;
    base: undefined;
    commands: {
        launchContent: Command<TypeFromFields<{
            autoPlay: FieldType<boolean>;
            data: OptionalFieldType<string>;
            playbackPreferences: OptionalFieldType<TypeFromFields<{
                audioTracks: OptionalFieldType<null | (...)[]>;
                playbackPosition: OptionalFieldType<null | number | bigint>;
                textTrack: OptionalFieldType<null | TypeFromFields<(...)>>;
            }>>;
            search: FieldType<TypeFromFields<{
                parameterList: FieldType<TypeFromFields<(...)>[]>;
            }>>;
            useCurrentContext: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<ContentLauncher.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                contentSearch: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        launchUrl: Command<TypeFromFields<{
            brandingInformation: OptionalFieldType<TypeFromFields<{
                background: OptionalFieldType<TypeFromFields<{
                    color: ...;
                    imageUrl: ...;
                    size: ...;
                }>>;
                logo: OptionalFieldType<TypeFromFields<{
                    color: ...;
                    imageUrl: ...;
                    size: ...;
                }>>;
                progressBar: OptionalFieldType<TypeFromFields<{
                    color: ...;
                    imageUrl: ...;
                    size: ...;
                }>>;
                providerName: FieldType<string>;
                splash: OptionalFieldType<TypeFromFields<{
                    color: ...;
                    imageUrl: ...;
                    size: ...;
                }>>;
                waterMark: OptionalFieldType<TypeFromFields<{
                    color: ...;
                    imageUrl: ...;
                    size: ...;
                }>>;
            }>>;
            contentUrl: FieldType<string>;
            displayString: OptionalFieldType<string>;
            playbackPreferences: OptionalFieldType<TypeFromFields<{
                audioTracks: OptionalFieldType<null | (...)[]>;
                playbackPosition: OptionalFieldType<null | number | bigint>;
                textTrack: OptionalFieldType<null | TypeFromFields<(...)>>;
            }>>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<ContentLauncher.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                urlPlayback: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {};
    extensions: undefined;
    features: {
        advancedSeek: BitFlag;
        audioTracks: BitFlag;
        contentSearch: BitFlag;
        textTracks: BitFlag;
        urlPlayback: BitFlag;
    };
    id: Branded<Branded<1290, "ClusterId">, "ClusterId">;
    name: "ContentLauncher";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptHeader: Attribute<string[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            urlPlayback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
        dash: BitFlag;
        hls: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            urlPlayback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    advancedSeek: BitFlag;
    audioTracks: BitFlag;
    contentSearch: BitFlag;
    textTracks: BitFlag;
    urlPlayback: BitFlag;
}>>

base

base: undefined

commands

commands: {
    launchContent: Command<TypeFromFields<{
        autoPlay: FieldType<boolean>;
        data: OptionalFieldType<string>;
        playbackPreferences: OptionalFieldType<TypeFromFields<{
            audioTracks: OptionalFieldType<null | (...)[]>;
            playbackPosition: OptionalFieldType<null | number | bigint>;
            textTrack: OptionalFieldType<null | TypeFromFields<(...)>>;
        }>>;
        search: FieldType<TypeFromFields<{
            parameterList: FieldType<TypeFromFields<(...)>[]>;
        }>>;
        useCurrentContext: OptionalFieldType<boolean>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<ContentLauncher.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            contentSearch: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    launchUrl: Command<TypeFromFields<{
        brandingInformation: OptionalFieldType<TypeFromFields<{
            background: OptionalFieldType<TypeFromFields<{
                color: ...;
                imageUrl: ...;
                size: ...;
            }>>;
            logo: OptionalFieldType<TypeFromFields<{
                color: ...;
                imageUrl: ...;
                size: ...;
            }>>;
            progressBar: OptionalFieldType<TypeFromFields<{
                color: ...;
                imageUrl: ...;
                size: ...;
            }>>;
            providerName: FieldType<string>;
            splash: OptionalFieldType<TypeFromFields<{
                color: ...;
                imageUrl: ...;
                size: ...;
            }>>;
            waterMark: OptionalFieldType<TypeFromFields<{
                color: ...;
                imageUrl: ...;
                size: ...;
            }>>;
        }>>;
        contentUrl: FieldType<string>;
        displayString: OptionalFieldType<string>;
        playbackPreferences: OptionalFieldType<TypeFromFields<{
            audioTracks: OptionalFieldType<null | (...)[]>;
            playbackPosition: OptionalFieldType<null | number | bigint>;
            textTrack: OptionalFieldType<null | TypeFromFields<(...)>>;
        }>>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<ContentLauncher.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            urlPlayback: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

events

events: {}

extensions

extensions: undefined

features

features: {
    advancedSeek: BitFlag;
    audioTracks: BitFlag;
    contentSearch: BitFlag;
    textTracks: BitFlag;
    urlPlayback: BitFlag;
}

Type declaration

  • ReadonlyadvancedSeek: BitFlag

    AdvancedSeek

    Enables clients to implement more advanced media seeking behavior in their user interface, such as for example a "seek bar".

  • ReadonlyaudioTracks: BitFlag

    AudioTracks

    Device or app supports Audio Tracks.

  • ReadonlycontentSearch: BitFlag

    ContentSearch

    Device supports content search (non-app specific)

  • ReadonlytextTracks: BitFlag

    TextTracks

    Device or app supports Text Tracks.

  • ReadonlyurlPlayback: BitFlag

    UrlPlayback

    Device supports basic URL-based file playback

id

id: Branded<Branded<1290, "ClusterId">, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptHeader: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                  dash: BitFlag;
                  hls: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              launchContent: Command<TypeFromFields<{
                  autoPlay: FieldType<boolean>;
                  data: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
                  search: FieldType<TypeFromFields<{
                      parameterList: ...;
                  }>>;
                  useCurrentContext: OptionalFieldType<boolean>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      contentSearch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              launchUrl: Command<TypeFromFields<{
                  brandingInformation: OptionalFieldType<TypeFromFields<{
                      background: ...;
                      logo: ...;
                      progressBar: ...;
                      providerName: ...;
                      splash: ...;
                      waterMark: ...;
                  }>>;
                  contentUrl: FieldType<string>;
                  displayString: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              advancedSeek: BitFlag;
              audioTracks: BitFlag;
              contentSearch: BitFlag;
              textTracks: BitFlag;
              urlPlayback: BitFlag;
          };
          id: Branded<1290, "ClusterId">;
          name: "ContentLauncher";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptHeader: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                  dash: BitFlag;
                  hls: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              launchContent: Command<TypeFromFields<{
                  autoPlay: FieldType<boolean>;
                  data: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
                  search: FieldType<TypeFromFields<{
                      parameterList: ...;
                  }>>;
                  useCurrentContext: OptionalFieldType<boolean>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      contentSearch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              launchUrl: Command<TypeFromFields<{
                  brandingInformation: OptionalFieldType<TypeFromFields<{
                      background: ...;
                      logo: ...;
                      progressBar: ...;
                      providerName: ...;
                      splash: ...;
                      waterMark: ...;
                  }>>;
                  contentUrl: FieldType<string>;
                  displayString: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              advancedSeek: BitFlag;
              audioTracks: BitFlag;
              contentSearch: BitFlag;
              textTracks: BitFlag;
              urlPlayback: BitFlag;
          };
          id: Branded<1290, "ClusterId">;
          name: "ContentLauncher";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          acceptHeader?: string[];
          supportedStreamingProtocols?: {
              dash?: boolean;
              hls?: boolean;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptHeader: Attribute<string[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                  dash: BitFlag;
                  hls: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              launchContent: Command<TypeFromFields<{
                  autoPlay: FieldType<boolean>;
                  data: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
                  search: FieldType<TypeFromFields<{
                      parameterList: ...;
                  }>>;
                  useCurrentContext: OptionalFieldType<boolean>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      contentSearch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              launchUrl: Command<TypeFromFields<{
                  brandingInformation: OptionalFieldType<TypeFromFields<{
                      background: ...;
                      logo: ...;
                      progressBar: ...;
                      providerName: ...;
                      splash: ...;
                      waterMark: ...;
                  }>>;
                  contentUrl: FieldType<string>;
                  displayString: OptionalFieldType<string>;
                  playbackPreferences: OptionalFieldType<TypeFromFields<{
                      audioTracks: ...;
                      playbackPosition: ...;
                      textTrack: ...;
                  }>>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<ContentLauncher.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      urlPlayback: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              advancedSeek: BitFlag;
              audioTracks: BitFlag;
              contentSearch: BitFlag;
              textTracks: BitFlag;
              urlPlayback: BitFlag;
          };
          id: Branded<1290, "ClusterId">;
          name: "ContentLauncher";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptHeader: Attribute<string[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedStreamingProtocols: Attribute<TypeFromPartialBitSchema<{
                dash: BitFlag;
                hls: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            launchContent: Command<TypeFromFields<{
                autoPlay: FieldType<boolean>;
                data: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
                search: FieldType<TypeFromFields<{
                    parameterList: ...;
                }>>;
                useCurrentContext: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    contentSearch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            launchUrl: Command<TypeFromFields<{
                brandingInformation: OptionalFieldType<TypeFromFields<{
                    background: ...;
                    logo: ...;
                    progressBar: ...;
                    providerName: ...;
                    splash: ...;
                    waterMark: ...;
                }>>;
                contentUrl: FieldType<string>;
                displayString: OptionalFieldType<string>;
                playbackPreferences: OptionalFieldType<TypeFromFields<{
                    audioTracks: ...;
                    playbackPosition: ...;
                    textTrack: ...;
                }>>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<ContentLauncher.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    urlPlayback: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            advancedSeek: BitFlag;
            audioTracks: BitFlag;
            contentSearch: BitFlag;
            textTracks: BitFlag;
            urlPlayback: BitFlag;
        };
        id: Branded<1290, "ClusterId">;
        name: "ContentLauncher";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods