Interface Cluster

This cluster provides an interface for controlling the current Channel on a device or endpoint.

This cluster server would be supported on Video Player devices or endpoints that allow Channel control such as a Content App. This cluster provides a list of available channels and provides commands for absolute and relative channel changes.

The cluster server for Channel is implemented by an endpoint that controls the current Channel.

ChannelCluster supports optional features that you can enable with the ChannelCluster.with() factory method.

See

MatterSpecification.v13.Cluster § 6.6

interface Cluster {
    attributes: Merge<{
        currentChannel: OptionalAttribute<null | TypeFromFields<{
            affiliateCallSign: OptionalFieldType<string>;
            callSign: OptionalFieldType<string>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
            name: OptionalFieldType<string>;
            type: OptionalFieldType<Channel.ChannelType>;
        }>, any>;
    }, GlobalAttributes<{
        channelList: BitFlag;
        electronicGuide: BitFlag;
        lineupInfo: BitFlag;
        recordProgram: BitFlag;
    }>>;
    base: undefined;
    commands: {
        changeChannelByNumber: Command<TypeFromFields<{
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
        }>, void, any>;
        skipChannel: Command<TypeFromFields<{
            count: FieldType<number>;
        }>, void, any>;
    };
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                channelList: Attribute<TypeFromFields<{
                    affiliateCallSign: OptionalFieldType<string>;
                    callSign: OptionalFieldType<string>;
                    identifier: OptionalFieldType<string>;
                    majorNumber: FieldType<number>;
                    minorNumber: FieldType<number>;
                    name: OptionalFieldType<string>;
                    type: OptionalFieldType<Channel.ChannelType>;
                }>[], any>;
            };
        };
        flags: {
            channelList: true;
        };
    }, {
        component: {
            attributes: {
                lineup: Attribute<null | TypeFromFields<{
                    lineupInfoType: FieldType<Mso>;
                    lineupName: OptionalFieldType<string>;
                    operatorName: FieldType<string>;
                    postalCode: OptionalFieldType<string>;
                }>, any>;
            };
        };
        flags: {
            lineupInfo: true;
        };
    }, {
        component: {
            commands: {
                changeChannel: Command<TypeFromFields<{
                    match: FieldType<string>;
                }>, TypeFromFields<{
                    data: OptionalFieldType<string>;
                    status: FieldType<Channel.Status>;
                }>, any>;
            };
        };
        flags: {
            channelList: true;
        };
    }, {
        component: {
            commands: {
                changeChannel: Command<TypeFromFields<{
                    match: FieldType<string>;
                }>, TypeFromFields<{
                    data: OptionalFieldType<string>;
                    status: FieldType<Channel.Status>;
                }>, any>;
            };
        };
        flags: {
            lineupInfo: true;
        };
    }, {
        component: {
            commands: {
                getProgramGuide: Command<TypeFromFields<{
                    channelList: OptionalFieldType<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[]>;
                    data: OptionalFieldType<Uint8Array>;
                    endTime: FieldType<number>;
                    externalIdList: OptionalFieldType<TypeFromFields<{
                        name: ...;
                        value: ...;
                    }>[]>;
                    pageToken: OptionalFieldType<null | TypeFromFields<{
                        after: ...;
                        before: ...;
                        limit: ...;
                    }>>;
                    recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<{
                        recorded: ...;
                        recordSeries: ...;
                        scheduled: ...;
                    }>>;
                    startTime: FieldType<number>;
                }>, TypeFromFields<{
                    paging: FieldType<TypeFromFields<{
                        nextToken: OptionalFieldType<(...)>;
                        previousToken: OptionalFieldType<(...)>;
                    }>>;
                    programList: FieldType<TypeFromFields<{
                        audioLanguages: ...;
                        castList: ...;
                        categoryList: ...;
                        channel: ...;
                        description: ...;
                        dvbiUrl: ...;
                        endTime: ...;
                        externalIdList: ...;
                        identifier: ...;
                        parentalGuidanceText: ...;
                        posterArtUrl: ...;
                        ratings: ...;
                        recordingFlag: ...;
                        releaseDate: ...;
                        seriesInfo: ...;
                        startTime: ...;
                        subtitle: ...;
                        thumbnailUrl: ...;
                        title: ...;
                    }>[]>;
                }>, any>;
            };
        };
        flags: {
            electronicGuide: true;
        };
    }, {
        component: {
            commands: {
                cancelRecordProgram: Command<TypeFromFields<{
                    data: OptionalFieldType<Uint8Array>;
                    externalIdList: OptionalFieldType<TypeFromFields<{
                        name: ...;
                        value: ...;
                    }>[]>;
                    programIdentifier: FieldType<string>;
                    shouldRecordSeries: FieldType<boolean>;
                }>, void, any>;
                recordProgram: Command<TypeFromFields<{
                    data: OptionalFieldType<Uint8Array>;
                    externalIdList: OptionalFieldType<TypeFromFields<{
                        name: ...;
                        value: ...;
                    }>[]>;
                    programIdentifier: FieldType<string>;
                    shouldRecordSeries: FieldType<boolean>;
                }>, void, any>;
            };
        };
        flags: {
            electronicGuide: true;
            recordProgram: true;
        };
    }];
    features: {
        channelList: BitFlag;
        electronicGuide: BitFlag;
        lineupInfo: BitFlag;
        recordProgram: BitFlag;
    };
    id: Branded<1284, "ClusterId">;
    name: "Channel";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    currentChannel: OptionalAttribute<null | TypeFromFields<{
        affiliateCallSign: OptionalFieldType<string>;
        callSign: OptionalFieldType<string>;
        identifier: OptionalFieldType<string>;
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
        name: OptionalFieldType<string>;
        type: OptionalFieldType<Channel.ChannelType>;
    }>, any>;
}, GlobalAttributes<{
    channelList: BitFlag;
    electronicGuide: BitFlag;
    lineupInfo: BitFlag;
    recordProgram: BitFlag;
}>>

Type declaration

base

base: undefined

commands

commands: {
    changeChannelByNumber: Command<TypeFromFields<{
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
    }>, void, any>;
    skipChannel: Command<TypeFromFields<{
        count: FieldType<number>;
    }>, void, any>;
}

Type declaration

  • ReadonlychangeChannelByNumber: Command<TypeFromFields<{
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
    }>, void, any>

    Change the channel to the channel with the given Number in the ChannelList attribute.

    See

    MatterSpecification.v13.Cluster § 6.6.7.3

  • ReadonlyskipChannel: Command<TypeFromFields<{
        count: FieldType<number>;
    }>, void, any>

    This command provides channel up and channel down functionality, but allows channel index jumps of size Count.

    When the value of the increase or decrease is larger than the number of channels remaining in the given direction, then the behavior shall be to return to the beginning (or end) of the channel list and continue. For example, if the current channel is at index 0 and count value of -1 is given, then the current channel should change to the last channel.

    See

    MatterSpecification.v13.Cluster § 6.6.7.4

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            channelList: Attribute<TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>[], any>;
        };
    };
    flags: {
        channelList: true;
    };
}, {
    component: {
        attributes: {
            lineup: Attribute<null | TypeFromFields<{
                lineupInfoType: FieldType<Mso>;
                lineupName: OptionalFieldType<string>;
                operatorName: FieldType<string>;
                postalCode: OptionalFieldType<string>;
            }>, any>;
        };
    };
    flags: {
        lineupInfo: true;
    };
}, {
    component: {
        commands: {
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any>;
        };
    };
    flags: {
        channelList: true;
    };
}, {
    component: {
        commands: {
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any>;
        };
    };
    flags: {
        lineupInfo: true;
    };
}, {
    component: {
        commands: {
            getProgramGuide: Command<TypeFromFields<{
                channelList: OptionalFieldType<TypeFromFields<{
                    affiliateCallSign: ...;
                    callSign: ...;
                    identifier: ...;
                    majorNumber: ...;
                    minorNumber: ...;
                    name: ...;
                    type: ...;
                }>[]>;
                data: OptionalFieldType<Uint8Array>;
                endTime: FieldType<number>;
                externalIdList: OptionalFieldType<TypeFromFields<{
                    name: ...;
                    value: ...;
                }>[]>;
                pageToken: OptionalFieldType<null | TypeFromFields<{
                    after: ...;
                    before: ...;
                    limit: ...;
                }>>;
                recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<{
                    recorded: ...;
                    recordSeries: ...;
                    scheduled: ...;
                }>>;
                startTime: FieldType<number>;
            }>, TypeFromFields<{
                paging: FieldType<TypeFromFields<{
                    nextToken: OptionalFieldType<(...)>;
                    previousToken: OptionalFieldType<(...)>;
                }>>;
                programList: FieldType<TypeFromFields<{
                    audioLanguages: ...;
                    castList: ...;
                    categoryList: ...;
                    channel: ...;
                    description: ...;
                    dvbiUrl: ...;
                    endTime: ...;
                    externalIdList: ...;
                    identifier: ...;
                    parentalGuidanceText: ...;
                    posterArtUrl: ...;
                    ratings: ...;
                    recordingFlag: ...;
                    releaseDate: ...;
                    seriesInfo: ...;
                    startTime: ...;
                    subtitle: ...;
                    thumbnailUrl: ...;
                    title: ...;
                }>[]>;
            }>, any>;
        };
    };
    flags: {
        electronicGuide: true;
    };
}, {
    component: {
        commands: {
            cancelRecordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<{
                    name: ...;
                    value: ...;
                }>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any>;
            recordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<{
                    name: ...;
                    value: ...;
                }>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any>;
        };
    };
    flags: {
        electronicGuide: true;
        recordProgram: true;
    };
}]

features

features: {
    channelList: BitFlag;
    electronicGuide: BitFlag;
    lineupInfo: BitFlag;
    recordProgram: BitFlag;
}

Type declaration

  • ReadonlychannelList: BitFlag

    ChannelList

    Provides list of available channels.

  • ReadonlyelectronicGuide: BitFlag

    ElectronicGuide

    Provides electronic program guide information.

  • ReadonlylineupInfo: BitFlag

    LineupInfo

    Provides lineup info, which is a reference to an external source of lineup information.

  • ReadonlyrecordProgram: BitFlag

    RecordProgram

    Provides ability to record program.

id

id: Branded<1284, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              currentChannel: OptionalAttribute<null | TypeFromFields<{
                  affiliateCallSign: OptionalFieldType<string>;
                  callSign: OptionalFieldType<string>;
                  identifier: OptionalFieldType<string>;
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
                  name: OptionalFieldType<string>;
                  type: OptionalFieldType<Channel.ChannelType>;
              }>, any>;
          };
          commands: {
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      channelList: Attribute<TypeFromFields<{
                          affiliateCallSign: ...;
                          callSign: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                          name: ...;
                          type: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  attributes: {
                      lineup: Attribute<null | TypeFromFields<{
                          lineupInfoType: ...;
                          lineupName: ...;
                          operatorName: ...;
                          postalCode: ...;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      getProgramGuide: Command<TypeFromFields<{
                          channelList: OptionalFieldType<(...)>;
                          data: OptionalFieldType<(...)>;
                          endTime: FieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          pageToken: OptionalFieldType<(...)>;
                          recordingFlag: OptionalFieldType<(...)>;
                          startTime: FieldType<(...)>;
                      }>, TypeFromFields<{
                          paging: FieldType<(...)>;
                          programList: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRecordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                      recordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
                  recordProgram: true;
              };
          }];
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: 1284;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              currentChannel: OptionalAttribute<null | TypeFromFields<{
                  affiliateCallSign: OptionalFieldType<string>;
                  callSign: OptionalFieldType<string>;
                  identifier: OptionalFieldType<string>;
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
                  name: OptionalFieldType<string>;
                  type: OptionalFieldType<Channel.ChannelType>;
              }>, any>;
          };
          commands: {
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      channelList: Attribute<TypeFromFields<{
                          affiliateCallSign: ...;
                          callSign: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                          name: ...;
                          type: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  attributes: {
                      lineup: Attribute<null | TypeFromFields<{
                          lineupInfoType: ...;
                          lineupName: ...;
                          operatorName: ...;
                          postalCode: ...;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      getProgramGuide: Command<TypeFromFields<{
                          channelList: OptionalFieldType<(...)>;
                          data: OptionalFieldType<(...)>;
                          endTime: FieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          pageToken: OptionalFieldType<(...)>;
                          recordingFlag: OptionalFieldType<(...)>;
                          startTime: FieldType<(...)>;
                      }>, TypeFromFields<{
                          paging: FieldType<(...)>;
                          programList: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRecordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                      recordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
                  recordProgram: true;
              };
          }];
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: 1284;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentChannel?: null | {
              affiliateCallSign?: string;
              callSign?: string;
              identifier?: string;
              majorNumber: number;
              minorNumber: number;
              name?: string;
              type?: number;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              currentChannel: OptionalAttribute<null | TypeFromFields<{
                  affiliateCallSign: OptionalFieldType<string>;
                  callSign: OptionalFieldType<string>;
                  identifier: OptionalFieldType<string>;
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
                  name: OptionalFieldType<string>;
                  type: OptionalFieldType<Channel.ChannelType>;
              }>, any>;
          };
          commands: {
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      channelList: Attribute<TypeFromFields<{
                          affiliateCallSign: ...;
                          callSign: ...;
                          identifier: ...;
                          majorNumber: ...;
                          minorNumber: ...;
                          name: ...;
                          type: ...;
                      }>[], any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  attributes: {
                      lineup: Attribute<null | TypeFromFields<{
                          lineupInfoType: ...;
                          lineupName: ...;
                          operatorName: ...;
                          postalCode: ...;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  channelList: true;
              };
          }, {
              component: {
                  commands: {
                      changeChannel: Command<TypeFromFields<{
                          match: FieldType<(...)>;
                      }>, TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          status: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  lineupInfo: true;
              };
          }, {
              component: {
                  commands: {
                      getProgramGuide: Command<TypeFromFields<{
                          channelList: OptionalFieldType<(...)>;
                          data: OptionalFieldType<(...)>;
                          endTime: FieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          pageToken: OptionalFieldType<(...)>;
                          recordingFlag: OptionalFieldType<(...)>;
                          startTime: FieldType<(...)>;
                      }>, TypeFromFields<{
                          paging: FieldType<(...)>;
                          programList: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
              };
          }, {
              component: {
                  commands: {
                      cancelRecordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                      recordProgram: Command<TypeFromFields<{
                          data: OptionalFieldType<(...)>;
                          externalIdList: OptionalFieldType<(...)>;
                          programIdentifier: FieldType<(...)>;
                          shouldRecordSeries: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  electronicGuide: true;
                  recordProgram: true;
              };
          }];
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: 1284;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            currentChannel: OptionalAttribute<null | TypeFromFields<{
                affiliateCallSign: OptionalFieldType<string>;
                callSign: OptionalFieldType<string>;
                identifier: OptionalFieldType<string>;
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
                name: OptionalFieldType<string>;
                type: OptionalFieldType<Channel.ChannelType>;
            }>, any>;
        };
        commands: {
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    channelList: Attribute<TypeFromFields<{
                        affiliateCallSign: ...;
                        callSign: ...;
                        identifier: ...;
                        majorNumber: ...;
                        minorNumber: ...;
                        name: ...;
                        type: ...;
                    }>[], any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                attributes: {
                    lineup: Attribute<null | TypeFromFields<{
                        lineupInfoType: ...;
                        lineupName: ...;
                        operatorName: ...;
                        postalCode: ...;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                channelList: true;
            };
        }, {
            component: {
                commands: {
                    changeChannel: Command<TypeFromFields<{
                        match: FieldType<(...)>;
                    }>, TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        status: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                lineupInfo: true;
            };
        }, {
            component: {
                commands: {
                    getProgramGuide: Command<TypeFromFields<{
                        channelList: OptionalFieldType<(...)>;
                        data: OptionalFieldType<(...)>;
                        endTime: FieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        pageToken: OptionalFieldType<(...)>;
                        recordingFlag: OptionalFieldType<(...)>;
                        startTime: FieldType<(...)>;
                    }>, TypeFromFields<{
                        paging: FieldType<(...)>;
                        programList: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                electronicGuide: true;
            };
        }, {
            component: {
                commands: {
                    cancelRecordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                    recordProgram: Command<TypeFromFields<{
                        data: OptionalFieldType<(...)>;
                        externalIdList: OptionalFieldType<(...)>;
                        programIdentifier: FieldType<(...)>;
                        shouldRecordSeries: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                electronicGuide: true;
                recordProgram: true;
            };
        }];
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: 1284;
        name: "Channel";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods