Interface Complete

This cluster supports all MediaPlayback 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<{
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<{
                characteristics: OptionalFieldType<(...)>;
                displayName: OptionalFieldType<(...)>;
                languageCode: FieldType<(...)>;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<{
                characteristics: OptionalFieldType<(...)>;
                displayName: OptionalFieldType<(...)>;
                languageCode: FieldType<(...)>;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<{
                characteristics: ...;
                displayName: ...;
                languageCode: ...;
            }>>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<{
                characteristics: ...;
                displayName: ...;
                languageCode: ...;
            }>>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<null | number | bigint>;
            updatedAt: FieldType<number | bigint>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    }>>;
    base: undefined;
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<null | number | bigint>;
                updatedAt: FieldType<number | bigint>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    extensions: undefined;
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<Branded<1286, "ClusterId">, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeAudioTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activeTextTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            availableAudioTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            availableTextTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentState: Attribute<MediaPlayback.PlaybackState, any>;
            duration: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                advancedSeek: BitFlag;
                audioAdvance: BitFlag;
                audioTracks: BitFlag;
                textTracks: BitFlag;
                variableSpeed: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            playbackSpeed: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sampledPosition: Attribute<null | TypeFromFields<{
                position: FieldType<(...) | (...) | (...)>;
                updatedAt: FieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeEnd: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeStart: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            activateAudioTrack: Command<TypeFromFields<{
                audioOutputIndex: OptionalFieldType<null | number>;
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activateTextTrack: Command<TypeFromFields<{
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            deactivateTextTrack: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            fastForward: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            next: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            pause: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            play: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            previous: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            rewind: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seek: Command<TypeFromFields<{
                position: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipBackward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            skipForward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            startOver: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            stop: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
        };
        events: {
            stateChanged: OptionalEvent<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
                currentState: FieldType<MediaPlayback.PlaybackState>;
                data: OptionalFieldType<Uint8Array>;
                duration: OptionalFieldType<number | bigint>;
                playbackSpeed: OptionalFieldType<number>;
                sampledPosition: OptionalFieldType<TypeFromFields<{
                    position: FieldType<(...)>;
                    updatedAt: FieldType<(...)>;
                }>>;
                seekRangeEnd: OptionalFieldType<number | bigint>;
                seekRangeStart: OptionalFieldType<number | bigint>;
                startTime: OptionalFieldType<number | bigint>;
            }>, any>;
        };
        features: {
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        };
        id: Branded<1286, "ClusterId">;
        name: "MediaPlayback";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeAudioTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activeTextTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            availableAudioTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            availableTextTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentState: Attribute<MediaPlayback.PlaybackState, any>;
            duration: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                advancedSeek: BitFlag;
                audioAdvance: BitFlag;
                audioTracks: BitFlag;
                textTracks: BitFlag;
                variableSpeed: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            playbackSpeed: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sampledPosition: Attribute<null | TypeFromFields<{
                position: FieldType<(...) | (...) | (...)>;
                updatedAt: FieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeEnd: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeStart: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            activateAudioTrack: Command<TypeFromFields<{
                audioOutputIndex: OptionalFieldType<null | number>;
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activateTextTrack: Command<TypeFromFields<{
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            deactivateTextTrack: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            fastForward: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            next: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            pause: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            play: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            previous: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            rewind: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seek: Command<TypeFromFields<{
                position: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipBackward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            skipForward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            startOver: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            stop: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
        };
        events: {
            stateChanged: OptionalEvent<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
                currentState: FieldType<MediaPlayback.PlaybackState>;
                data: OptionalFieldType<Uint8Array>;
                duration: OptionalFieldType<number | bigint>;
                playbackSpeed: OptionalFieldType<number>;
                sampledPosition: OptionalFieldType<TypeFromFields<{
                    position: FieldType<(...)>;
                    updatedAt: FieldType<(...)>;
                }>>;
                seekRangeEnd: OptionalFieldType<number | bigint>;
                seekRangeStart: OptionalFieldType<number | bigint>;
                startTime: OptionalFieldType<number | bigint>;
            }>, any>;
        };
        features: {
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        };
        id: Branded<1286, "ClusterId">;
        name: "MediaPlayback";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeAudioTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activeTextTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            availableAudioTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            availableTextTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentState: Attribute<MediaPlayback.PlaybackState, any>;
            duration: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                advancedSeek: BitFlag;
                audioAdvance: BitFlag;
                audioTracks: BitFlag;
                textTracks: BitFlag;
                variableSpeed: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            playbackSpeed: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sampledPosition: Attribute<null | TypeFromFields<{
                position: FieldType<(...) | (...) | (...)>;
                updatedAt: FieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeEnd: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeStart: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            activateAudioTrack: Command<TypeFromFields<{
                audioOutputIndex: OptionalFieldType<null | number>;
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activateTextTrack: Command<TypeFromFields<{
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            deactivateTextTrack: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            fastForward: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            next: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            pause: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            play: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            previous: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            rewind: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seek: Command<TypeFromFields<{
                position: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipBackward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            skipForward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            startOver: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            stop: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
        };
        events: {
            stateChanged: OptionalEvent<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
                currentState: FieldType<MediaPlayback.PlaybackState>;
                data: OptionalFieldType<Uint8Array>;
                duration: OptionalFieldType<number | bigint>;
                playbackSpeed: OptionalFieldType<number>;
                sampledPosition: OptionalFieldType<TypeFromFields<{
                    position: FieldType<(...)>;
                    updatedAt: FieldType<(...)>;
                }>>;
                seekRangeEnd: OptionalFieldType<number | bigint>;
                seekRangeStart: OptionalFieldType<number | bigint>;
                startTime: OptionalFieldType<number | bigint>;
            }>, any>;
        };
        features: {
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        };
        id: Branded<1286, "ClusterId">;
        name: "MediaPlayback";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeAudioTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activeTextTrack: Attribute<null | TypeFromFields<{
                id: FieldType<string>;
                trackAttributes: FieldType<TypeFromFields<(...)>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            availableAudioTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            availableTextTracks: Attribute<null | TypeFromFields<{
                id: FieldType<(...)>;
                trackAttributes: FieldType<(...)>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentState: Attribute<MediaPlayback.PlaybackState, any>;
            duration: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                advancedSeek: BitFlag;
                audioAdvance: BitFlag;
                audioTracks: BitFlag;
                textTracks: BitFlag;
                variableSpeed: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            playbackSpeed: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sampledPosition: Attribute<null | TypeFromFields<{
                position: FieldType<(...) | (...) | (...)>;
                updatedAt: FieldType<(...) | (...)>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeEnd: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seekRangeStart: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            startTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            activateAudioTrack: Command<TypeFromFields<{
                audioOutputIndex: OptionalFieldType<null | number>;
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    audioTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            activateTextTrack: Command<TypeFromFields<{
                trackId: FieldType<string>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            deactivateTextTrack: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    textTracks: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            fastForward: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            next: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            pause: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            play: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            previous: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            rewind: Command<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    variableSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            seek: Command<TypeFromFields<{
                position: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    advancedSeek: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipBackward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            skipForward: OptionalCommand<TypeFromFields<{
                deltaPositionMilliseconds: FieldType<number | bigint>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            startOver: OptionalCommand<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
            stop: Command<void, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<MediaPlayback.Status>;
            }>, any>;
        };
        events: {
            stateChanged: OptionalEvent<TypeFromFields<{
                audioAdvanceUnmuted: OptionalFieldType<boolean>;
                currentState: FieldType<MediaPlayback.PlaybackState>;
                data: OptionalFieldType<Uint8Array>;
                duration: OptionalFieldType<number | bigint>;
                playbackSpeed: OptionalFieldType<number>;
                sampledPosition: OptionalFieldType<TypeFromFields<{
                    position: FieldType<(...)>;
                    updatedAt: FieldType<(...)>;
                }>>;
                seekRangeEnd: OptionalFieldType<number | bigint>;
                seekRangeStart: OptionalFieldType<number | bigint>;
                startTime: OptionalFieldType<number | bigint>;
            }>, any>;
        };
        features: {
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        };
        id: Branded<1286, "ClusterId">;
        name: "MediaPlayback";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof MediaPlayback.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    activeAudioTrack: Attribute<null | TypeFromFields<{
        id: FieldType<string>;
        trackAttributes: FieldType<TypeFromFields<{
            characteristics: OptionalFieldType<(...)>;
            displayName: OptionalFieldType<(...)>;
            languageCode: FieldType<(...)>;
        }>>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            audioTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    activeTextTrack: Attribute<null | TypeFromFields<{
        id: FieldType<string>;
        trackAttributes: FieldType<TypeFromFields<{
            characteristics: OptionalFieldType<(...)>;
            displayName: OptionalFieldType<(...)>;
            languageCode: FieldType<(...)>;
        }>>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            textTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    attributeList: Attribute<AttributeId[], never>;
    availableAudioTracks: Attribute<null | TypeFromFields<{
        id: FieldType<string>;
        trackAttributes: FieldType<TypeFromFields<{
            characteristics: ...;
            displayName: ...;
            languageCode: ...;
        }>>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            audioTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    availableTextTracks: Attribute<null | TypeFromFields<{
        id: FieldType<string>;
        trackAttributes: FieldType<TypeFromFields<{
            characteristics: ...;
            displayName: ...;
            languageCode: ...;
        }>>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            textTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clusterRevision: Attribute<number, never>;
    currentState: Attribute<MediaPlayback.PlaybackState, any>;
    duration: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    featureMap: Attribute<TypeFromPartialBitSchema<{
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    playbackSpeed: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    sampledPosition: Attribute<null | TypeFromFields<{
        position: FieldType<null | number | bigint>;
        updatedAt: FieldType<number | bigint>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    seekRangeEnd: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    seekRangeStart: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    startTime: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    advancedSeek: BitFlag;
    audioAdvance: BitFlag;
    audioTracks: BitFlag;
    textTracks: BitFlag;
    variableSpeed: BitFlag;
}>>

Type declaration

ReadonlyacceptedCommandList: Attribute<CommandId[], never>
List of client generated commands which are supported by this cluster server instance.
ReadonlyactiveAudioTrack: Attribute<null | TypeFromFields<{
    id: FieldType<string>;
    trackAttributes: FieldType<TypeFromFields<{
        characteristics: OptionalFieldType<(...)>;
        displayName: OptionalFieldType<(...)>;
        languageCode: FieldType<(...)>;
    }>>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        audioTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyactiveTextTrack: Attribute<null | TypeFromFields<{
    id: FieldType<string>;
    trackAttributes: FieldType<TypeFromFields<{
        characteristics: OptionalFieldType<(...)>;
        displayName: OptionalFieldType<(...)>;
        languageCode: FieldType<(...)>;
    }>>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        textTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyattributeList: Attribute<AttributeId[], never>
List of the attribute IDs of the attributes supported by the cluster instance.
ReadonlyavailableAudioTracks: Attribute<null | TypeFromFields<{
    id: FieldType<string>;
    trackAttributes: FieldType<TypeFromFields<{
        characteristics: ...;
        displayName: ...;
        languageCode: ...;
    }>>;
}>[], any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        audioTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyavailableTextTracks: Attribute<null | TypeFromFields<{
    id: FieldType<string>;
    trackAttributes: FieldType<TypeFromFields<{
        characteristics: ...;
        displayName: ...;
        languageCode: ...;
    }>>;
}>[], any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        textTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyclusterRevision: Attribute<number, never>
Indicates the revision of the server cluster specification supported by the cluster instance.
ReadonlycurrentState: Attribute<MediaPlayback.PlaybackState, any>
Indicates the current playback state of media.

During fast-forward, rewind, and other seek operations; this attribute shall be set to PLAYING.

See
MatterSpecification.v13.Cluster § 6.10.6.1
Readonlyduration: Attribute<null | number | bigint, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
    advancedSeek: BitFlag;
    audioAdvance: BitFlag;
    audioTracks: BitFlag;
    textTracks: BitFlag;
    variableSpeed: BitFlag;
}>, never>
Indicates whether the server supports zero or more optional cluster features.
ReadonlygeneratedCommandList: Attribute<CommandId[], never>
List of server generated commands (server to client commands).
ReadonlyplaybackSpeed: Attribute<number, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysampledPosition: Attribute<null | TypeFromFields<{
    position: FieldType<null | number | bigint>;
    updatedAt: FieldType<number | bigint>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyseekRangeEnd: Attribute<null | number | bigint, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyseekRangeStart: Attribute<null | number | bigint, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlystartTime: Attribute<null | number | bigint, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

base

base: undefined

commands

commands: {
    activateAudioTrack: Command<TypeFromFields<{
        audioOutputIndex: OptionalFieldType<null | number>;
        trackId: FieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            audioTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    activateTextTrack: Command<TypeFromFields<{
        trackId: FieldType<string>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            textTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    deactivateTextTrack: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            textTracks: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    fastForward: Command<TypeFromFields<{
        audioAdvanceUnmuted: OptionalFieldType<boolean>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            variableSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    next: OptionalCommand<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    pause: Command<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    play: Command<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    previous: OptionalCommand<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    rewind: Command<TypeFromFields<{
        audioAdvanceUnmuted: OptionalFieldType<boolean>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            variableSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    seek: Command<TypeFromFields<{
        position: FieldType<number | bigint>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            advancedSeek: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    skipBackward: OptionalCommand<TypeFromFields<{
        deltaPositionMilliseconds: FieldType<number | bigint>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    skipForward: OptionalCommand<TypeFromFields<{
        deltaPositionMilliseconds: FieldType<number | bigint>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    startOver: OptionalCommand<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
    stop: Command<void, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<MediaPlayback.Status>;
    }>, any>;
}

Type declaration

ReadonlyactivateAudioTrack: Command<TypeFromFields<{
    audioOutputIndex: OptionalFieldType<null | number>;
    trackId: FieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        audioTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyactivateTextTrack: Command<TypeFromFields<{
    trackId: FieldType<string>;
}>, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        textTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlydeactivateTextTrack: Command<void, void, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        textTracks: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyfastForward: Command<TypeFromFields<{
    audioAdvanceUnmuted: OptionalFieldType<boolean>;
}>, TypeFromFields<{
    data: OptionalFieldType<string>;
    status: FieldType<MediaPlayback.Status>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        variableSpeed: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
Readonlynext: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall cause the handler to be invoked for "Next". User experience is context- specific. This will often Go forward to the next media playback item.

See
MatterSpecification.v13.Cluster § 6.10.7.6
Readonlypause: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall pause playback of the media.

See
MatterSpecification.v13.Cluster § 6.10.7.2
Readonlyplay: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall play media. If content is currently in a FastForward or Rewind state. Play shall return media to normal playback speed.

See
MatterSpecification.v13.Cluster § 6.10.7.1
Readonlyprevious: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall cause the handler to be invoked for "Previous". User experience is context-specific. This will often Go back to the previous media playback item.

See
MatterSpecification.v13.Cluster § 6.10.7.5
Readonlyrewind: Command<TypeFromFields<{
    audioAdvanceUnmuted: OptionalFieldType<boolean>;
}>, TypeFromFields<{
    data: OptionalFieldType<string>;
    status: FieldType<MediaPlayback.Status>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        variableSpeed: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
Readonlyseek: Command<TypeFromFields<{
    position: FieldType<number | bigint>;
}>, TypeFromFields<{
    data: OptionalFieldType<string>;
    status: FieldType<MediaPlayback.Status>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        advancedSeek: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyskipBackward: OptionalCommand<TypeFromFields<{
    deltaPositionMilliseconds: FieldType<number | bigint>;
}>, TypeFromFields<{
    data: OptionalFieldType<string>;
    status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall Skip backward in the media by the given number of milliseconds.

See
MatterSpecification.v13.Cluster § 6.10.7.10
ReadonlyskipForward: OptionalCommand<TypeFromFields<{
    deltaPositionMilliseconds: FieldType<number | bigint>;
}>, TypeFromFields<{
    data: OptionalFieldType<string>;
    status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall Skip forward in the media by the given number of milliseconds.

See
MatterSpecification.v13.Cluster § 6.10.7.9
ReadonlystartOver: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall Start Over with the current media playback item.

See
MatterSpecification.v13.Cluster § 6.10.7.4
Readonlystop: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>
Upon receipt, this shall stop playback of the media. User-visible outcome is context-specific. This may navigate the user back to the location from where the media was originally launched.

See
MatterSpecification.v13.Cluster § 6.10.7.3

events

events: {
    stateChanged: OptionalEvent<TypeFromFields<{
        audioAdvanceUnmuted: OptionalFieldType<boolean>;
        currentState: FieldType<MediaPlayback.PlaybackState>;
        data: OptionalFieldType<Uint8Array>;
        duration: OptionalFieldType<number | bigint>;
        playbackSpeed: OptionalFieldType<number>;
        sampledPosition: OptionalFieldType<TypeFromFields<{
            position: FieldType<null | number | bigint>;
            updatedAt: FieldType<number | bigint>;
        }>>;
        seekRangeEnd: OptionalFieldType<number | bigint>;
        seekRangeStart: OptionalFieldType<number | bigint>;
        startTime: OptionalFieldType<number | bigint>;
    }>, any>;
}

Type declaration

ReadonlystateChanged: OptionalEvent<TypeFromFields<{
    audioAdvanceUnmuted: OptionalFieldType<boolean>;
    currentState: FieldType<MediaPlayback.PlaybackState>;
    data: OptionalFieldType<Uint8Array>;
    duration: OptionalFieldType<number | bigint>;
    playbackSpeed: OptionalFieldType<number>;
    sampledPosition: OptionalFieldType<TypeFromFields<{
        position: FieldType<null | number | bigint>;
        updatedAt: FieldType<number | bigint>;
    }>>;
    seekRangeEnd: OptionalFieldType<number | bigint>;
    seekRangeStart: OptionalFieldType<number | bigint>;
    startTime: OptionalFieldType<number | bigint>;
}>, any>
If supported, this event shall be generated when there is a change in any of the supported attributes of the Media Playback cluster.

See
MatterSpecification.v13.Cluster § 6.10.8.1

extensions

extensions: undefined

features

features: {
    advancedSeek: BitFlag;
    audioAdvance: BitFlag;
    audioTracks: BitFlag;
    textTracks: BitFlag;
    variableSpeed: BitFlag;
}

Type declaration

ReadonlyadvancedSeek: BitFlag
AdvancedSeek

This feature provides access to the time offset location within current playback media and allows for jumping to a specific location using time offsets. This enables clients to implement more advanced media seeking behavior in their user interface, for instance a "seek bar".

See
MatterSpecification.v13.Cluster § 6.10.4.1
ReadonlyaudioAdvance: BitFlag
AudioAdvance

This feature is for a device or app that supports playing audio during fast and slow advance and rewind (e.g., while playback speed is not 1). A device that supports this feature may only support playing audio during certain speeds.

A cluster implementing AA shall implement AS.

See
MatterSpecification.v13.Cluster § 6.10.4.5
ReadonlyaudioTracks: BitFlag
AudioTracks

This feature is for a device or app that supports Audio Tracks.

See
MatterSpecification.v13.Cluster § 6.10.4.4
ReadonlytextTracks: BitFlag
TextTracks

This feature is for a device or app that supports Text Tracks.

See
MatterSpecification.v13.Cluster § 6.10.4.3
ReadonlyvariableSpeed: BitFlag
VariableSpeed

This feature is for a device which supports variable speed playback on media that supports it.

See
MatterSpecification.v13.Cluster § 6.10.4.2

id

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

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeAudioTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activeTextTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          availableAudioTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          availableTextTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentState: Attribute<MediaPlayback.PlaybackState, any>;
          duration: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              advancedSeek: BitFlag;
              audioAdvance: BitFlag;
              audioTracks: BitFlag;
              textTracks: BitFlag;
              variableSpeed: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          playbackSpeed: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sampledPosition: Attribute<null | TypeFromFields<{
              position: FieldType<(...) | (...) | (...)>;
              updatedAt: FieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeEnd: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeStart: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          startTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          activateAudioTrack: Command<TypeFromFields<{
              audioOutputIndex: OptionalFieldType<null | number>;
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activateTextTrack: Command<TypeFromFields<{
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          deactivateTextTrack: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          fastForward: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          next: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          pause: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          play: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          previous: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          rewind: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seek: Command<TypeFromFields<{
              position: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          skipBackward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          skipForward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          startOver: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          stop: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
      };
      events: {
          stateChanged: OptionalEvent<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
              currentState: FieldType<MediaPlayback.PlaybackState>;
              data: OptionalFieldType<Uint8Array>;
              duration: OptionalFieldType<number | bigint>;
              playbackSpeed: OptionalFieldType<number>;
              sampledPosition: OptionalFieldType<TypeFromFields<{
                  position: FieldType<(...)>;
                  updatedAt: FieldType<(...)>;
              }>>;
              seekRangeEnd: OptionalFieldType<number | bigint>;
              seekRangeStart: OptionalFieldType<number | bigint>;
              startTime: OptionalFieldType<number | bigint>;
          }>, any>;
      };
      features: {
          advancedSeek: BitFlag;
          audioAdvance: BitFlag;
          audioTracks: BitFlag;
          textTracks: BitFlag;
          variableSpeed: BitFlag;
      };
      id: Branded<1286, "ClusterId">;
      name: "MediaPlayback";
      revision: 2;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:82

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeAudioTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activeTextTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          availableAudioTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          availableTextTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentState: Attribute<MediaPlayback.PlaybackState, any>;
          duration: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              advancedSeek: BitFlag;
              audioAdvance: BitFlag;
              audioTracks: BitFlag;
              textTracks: BitFlag;
              variableSpeed: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          playbackSpeed: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sampledPosition: Attribute<null | TypeFromFields<{
              position: FieldType<(...) | (...) | (...)>;
              updatedAt: FieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeEnd: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeStart: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          startTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          activateAudioTrack: Command<TypeFromFields<{
              audioOutputIndex: OptionalFieldType<null | number>;
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activateTextTrack: Command<TypeFromFields<{
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          deactivateTextTrack: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          fastForward: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          next: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          pause: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          play: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          previous: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          rewind: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seek: Command<TypeFromFields<{
              position: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          skipBackward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          skipForward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          startOver: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          stop: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
      };
      events: {
          stateChanged: OptionalEvent<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
              currentState: FieldType<MediaPlayback.PlaybackState>;
              data: OptionalFieldType<Uint8Array>;
              duration: OptionalFieldType<number | bigint>;
              playbackSpeed: OptionalFieldType<number>;
              sampledPosition: OptionalFieldType<TypeFromFields<{
                  position: FieldType<(...)>;
                  updatedAt: FieldType<(...)>;
              }>>;
              seekRangeEnd: OptionalFieldType<number | bigint>;
              seekRangeStart: OptionalFieldType<number | bigint>;
              startTime: OptionalFieldType<number | bigint>;
          }>, any>;
      };
      features: {
          advancedSeek: BitFlag;
          audioAdvance: BitFlag;
          audioTracks: BitFlag;
          textTracks: BitFlag;
          variableSpeed: BitFlag;
      };
      id: Branded<1286, "ClusterId">;
      name: "MediaPlayback";
      revision: 2;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:96

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      activeAudioTrack?: null | {
          id: string;
          trackAttributes: {
              characteristics?: null | number[];
              displayName?: null | string;
              languageCode: string;
          };
      };
      activeTextTrack?: null | {
          id: string;
          trackAttributes: {
              characteristics?: null | number[];
              displayName?: null | string;
              languageCode: string;
          };
      };
      availableAudioTracks?: null | {
          id: string;
          trackAttributes: {
              characteristics?: null | number[];
              displayName?: null | string;
              languageCode: string;
          };
      }[];
      availableTextTracks?: null | {
          id: string;
          trackAttributes: {
              characteristics?: null | number[];
              displayName?: null | string;
              languageCode: string;
          };
      }[];
      currentState: number;
      duration?: null | number | bigint;
      playbackSpeed?: number;
      sampledPosition?: null | {
          position: null | number | bigint;
          updatedAt: number | bigint;
      };
      seekRangeEnd?: null | number | bigint;
      seekRangeStart?: null | number | bigint;
      startTime?: null | number | bigint;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:89

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeAudioTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activeTextTrack: Attribute<null | TypeFromFields<{
              id: FieldType<string>;
              trackAttributes: FieldType<TypeFromFields<(...)>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          availableAudioTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          availableTextTracks: Attribute<null | TypeFromFields<{
              id: FieldType<(...)>;
              trackAttributes: FieldType<(...)>;
          }>[], any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentState: Attribute<MediaPlayback.PlaybackState, any>;
          duration: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              advancedSeek: BitFlag;
              audioAdvance: BitFlag;
              audioTracks: BitFlag;
              textTracks: BitFlag;
              variableSpeed: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          playbackSpeed: Attribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sampledPosition: Attribute<null | TypeFromFields<{
              position: FieldType<(...) | (...) | (...)>;
              updatedAt: FieldType<(...) | (...)>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeEnd: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seekRangeStart: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          startTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          activateAudioTrack: Command<TypeFromFields<{
              audioOutputIndex: OptionalFieldType<null | number>;
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  audioTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          activateTextTrack: Command<TypeFromFields<{
              trackId: FieldType<string>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          deactivateTextTrack: Command<void, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  textTracks: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          fastForward: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          next: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          pause: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          play: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          previous: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          rewind: Command<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  variableSpeed: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          seek: Command<TypeFromFields<{
              position: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  advancedSeek: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          skipBackward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          skipForward: OptionalCommand<TypeFromFields<{
              deltaPositionMilliseconds: FieldType<number | bigint>;
          }>, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          startOver: OptionalCommand<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
          stop: Command<void, TypeFromFields<{
              data: OptionalFieldType<string>;
              status: FieldType<MediaPlayback.Status>;
          }>, any>;
      };
      events: {
          stateChanged: OptionalEvent<TypeFromFields<{
              audioAdvanceUnmuted: OptionalFieldType<boolean>;
              currentState: FieldType<MediaPlayback.PlaybackState>;
              data: OptionalFieldType<Uint8Array>;
              duration: OptionalFieldType<number | bigint>;
              playbackSpeed: OptionalFieldType<number>;
              sampledPosition: OptionalFieldType<TypeFromFields<{
                  position: FieldType<(...)>;
                  updatedAt: FieldType<(...)>;
              }>>;
              seekRangeEnd: OptionalFieldType<number | bigint>;
              seekRangeStart: OptionalFieldType<number | bigint>;
              startTime: OptionalFieldType<number | bigint>;
          }>, any>;
      };
      features: {
          advancedSeek: BitFlag;
          audioAdvance: BitFlag;
          audioTracks: BitFlag;
          textTracks: BitFlag;
          variableSpeed: BitFlag;
      };
      id: Branded<1286, "ClusterId">;
      name: "MediaPlayback";
      revision: 2;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeAudioTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activeTextTrack: Attribute<null | TypeFromFields<{
            id: FieldType<string>;
            trackAttributes: FieldType<TypeFromFields<(...)>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        availableAudioTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        availableTextTracks: Attribute<null | TypeFromFields<{
            id: FieldType<(...)>;
            trackAttributes: FieldType<(...)>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentState: Attribute<MediaPlayback.PlaybackState, any>;
        duration: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            advancedSeek: BitFlag;
            audioAdvance: BitFlag;
            audioTracks: BitFlag;
            textTracks: BitFlag;
            variableSpeed: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        playbackSpeed: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sampledPosition: Attribute<null | TypeFromFields<{
            position: FieldType<(...) | (...) | (...)>;
            updatedAt: FieldType<(...) | (...)>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeEnd: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seekRangeStart: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        startTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        activateAudioTrack: Command<TypeFromFields<{
            audioOutputIndex: OptionalFieldType<null | number>;
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                audioTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        activateTextTrack: Command<TypeFromFields<{
            trackId: FieldType<string>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        deactivateTextTrack: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                textTracks: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        fastForward: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        next: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        pause: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        play: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        previous: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        rewind: Command<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                variableSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        seek: Command<TypeFromFields<{
            position: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                advancedSeek: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        skipBackward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        skipForward: OptionalCommand<TypeFromFields<{
            deltaPositionMilliseconds: FieldType<number | bigint>;
        }>, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        startOver: OptionalCommand<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
        stop: Command<void, TypeFromFields<{
            data: OptionalFieldType<string>;
            status: FieldType<MediaPlayback.Status>;
        }>, any>;
    };
    events: {
        stateChanged: OptionalEvent<TypeFromFields<{
            audioAdvanceUnmuted: OptionalFieldType<boolean>;
            currentState: FieldType<MediaPlayback.PlaybackState>;
            data: OptionalFieldType<Uint8Array>;
            duration: OptionalFieldType<number | bigint>;
            playbackSpeed: OptionalFieldType<number>;
            sampledPosition: OptionalFieldType<TypeFromFields<{
                position: FieldType<(...)>;
                updatedAt: FieldType<(...)>;
            }>>;
            seekRangeEnd: OptionalFieldType<number | bigint>;
            seekRangeStart: OptionalFieldType<number | bigint>;
            startTime: OptionalFieldType<number | bigint>;
        }>, any>;
    };
    features: {
        advancedSeek: BitFlag;
        audioAdvance: BitFlag;
        audioTracks: BitFlag;
        textTracks: BitFlag;
        variableSpeed: BitFlag;
    };
    id: Branded<1286, "ClusterId">;
    name: "MediaPlayback";
    revision: 2;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:75

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

ReadonlyacceptedCommandList: Attribute<CommandId[], never>

ReadonlyattributeList: Attribute<AttributeId[], never>

ReadonlyclusterRevision: Attribute<number, never>

ReadonlycurrentState: Attribute<MediaPlayback.PlaybackState, any>

See

Readonlyduration: Attribute<null | number | bigint, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{ advancedSeek: BitFlag; audioAdvance: BitFlag; audioTracks: BitFlag; textTracks: BitFlag; variableSpeed: BitFlag; }>, never>

ReadonlygeneratedCommandList: Attribute<CommandId[], never>

ReadonlyplaybackSpeed: Attribute<number, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlysampledPosition: Attribute<null | TypeFromFields<{ position: FieldType<null | number | bigint>; updatedAt: FieldType<number | bigint>; }>, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyseekRangeEnd: Attribute<null | number | bigint, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyseekRangeStart: Attribute<null | number | bigint, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlystartTime: Attribute<null | number | bigint, any> & { isConditional: true; mandatoryIf: [] | [{ advancedSeek: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

base

commands

Type declaration

ReadonlyactivateAudioTrack: Command<TypeFromFields<{ audioOutputIndex: OptionalFieldType<null | number>; trackId: FieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ audioTracks: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyactivateTextTrack: Command<TypeFromFields<{ trackId: FieldType<string>; }>, void, any> & { isConditional: true; mandatoryIf: [] | [{ textTracks: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlydeactivateTextTrack: Command<void, void, any> & { isConditional: true; mandatoryIf: [] | [{ textTracks: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

Readonlynext: OptionalCommand<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

Readonlypause: Command<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

Readonlyplay: Command<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

Readonlyprevious: OptionalCommand<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

ReadonlyskipBackward: OptionalCommand<TypeFromFields<{ deltaPositionMilliseconds: FieldType<number | bigint>; }>, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

ReadonlyskipForward: OptionalCommand<TypeFromFields<{ deltaPositionMilliseconds: FieldType<number | bigint>; }>, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

ReadonlystartOver: OptionalCommand<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

Readonlystop: Command<void, TypeFromFields<{ data: OptionalFieldType<string>; status: FieldType<MediaPlayback.Status>; }>, any>

See

events

Type declaration

See

extensions

features

Type declaration

ReadonlyadvancedSeek: BitFlag

See

ReadonlyaudioAdvance: BitFlag

See

ReadonlyaudioTracks: BitFlag

See

ReadonlytextTracks: BitFlag

See

ReadonlyvariableSpeed: BitFlag

See

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`acceptedCommandList: Attribute<CommandId[], never>

`Readonly`attributeList: Attribute<AttributeId[], never>

`Readonly`clusterRevision: Attribute<number, never>

`Readonly`currentState: Attribute<MediaPlayback.PlaybackState, any>

`Readonly`duration: Attribute<null | number | bigint, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`featureMap: Attribute<TypeFromPartialBitSchema<{
advancedSeek: BitFlag;
audioAdvance: BitFlag;
audioTracks: BitFlag;
textTracks: BitFlag;
variableSpeed: BitFlag;
}>, never>

`Readonly`generatedCommandList: Attribute<CommandId[], never>

`Readonly`playbackSpeed: Attribute<number, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`sampledPosition: Attribute<null | TypeFromFields<{
position: FieldType<null | number | bigint>;
updatedAt: FieldType<number | bigint>;
}>, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`seekRangeEnd: Attribute<null | number | bigint, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`seekRangeStart: Attribute<null | number | bigint, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`startTime: Attribute<null | number | bigint, any> & {
isConditional: true;
mandatoryIf: [] | [{
advancedSeek: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`activateAudioTrack: Command<TypeFromFields<{
audioOutputIndex: OptionalFieldType<null | number>;
trackId: FieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
audioTracks: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`activateTextTrack: Command<TypeFromFields<{
trackId: FieldType<string>;
}>, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
textTracks: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`deactivateTextTrack: Command<void, void, any> & {
isConditional: true;
mandatoryIf: [] | [{
textTracks: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`next: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`pause: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`play: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`previous: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`skipBackward: OptionalCommand<TypeFromFields<{
deltaPositionMilliseconds: FieldType<number | bigint>;
}>, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`skipForward: OptionalCommand<TypeFromFields<{
deltaPositionMilliseconds: FieldType<number | bigint>;
}>, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`startOver: OptionalCommand<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`stop: Command<void, TypeFromFields<{
data: OptionalFieldType<string>;
status: FieldType<MediaPlayback.Status>;
}>, any>

`Readonly`advancedSeek: BitFlag

`Readonly`audioAdvance: BitFlag

`Readonly`audioTracks: BitFlag

`Readonly`textTracks: BitFlag

`Readonly`variableSpeed: BitFlag