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)

Identity<typeof Channel.ClusterInstance>
- Cluster

Index

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

ReadonlycurrentChannel: 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>
This attribute shall contain the current channel. When supported but a channel is not currently tuned to (if a content application is in foreground), the value of the field shall be null.

See
MatterSpecification.v13.Cluster § 6.6.6.3

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

revision

supportedFeatures

supportedFeatures: {}

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
- alterations: AlterationsT
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>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

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
- flags: FlagsT
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>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

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
- values: ValuesT
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>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

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
- Rest...selection: SelectionT
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>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Cluster

See

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

See

base

commands

Type declaration

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

See

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

See

events

extensions

features

Type declaration

ReadonlychannelList: BitFlag

ReadonlyelectronicGuide: BitFlag

ReadonlylineupInfo: BitFlag

ReadonlyrecordProgram: BitFlag

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`changeChannelByNumber: Command<TypeFromFields<{
majorNumber: FieldType<number>;
minorNumber: FieldType<number>;
}>, void, any>

`Readonly`skipChannel: Command<TypeFromFields<{
count: FieldType<number>;
}>, void, any>

`Readonly`channelList: BitFlag

`Readonly`electronicGuide: BitFlag

`Readonly`lineupInfo: BitFlag

`Readonly`recordProgram: BitFlag