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

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

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

Hierarchy (view full)

Properties

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    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> & {
        isConditional: true;
        mandatoryIf: [] | [{
            channelList: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clusterRevision: Attribute<number, never>;
    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>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        channelList: BitFlag;
        electronicGuide: BitFlag;
        lineupInfo: BitFlag;
        recordProgram: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    lineup: Attribute<null | TypeFromFields<{
        lineupInfoType: FieldType<Mso>;
        lineupName: OptionalFieldType<string>;
        operatorName: FieldType<string>;
        postalCode: OptionalFieldType<string>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lineupInfo: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    channelList: BitFlag;
    electronicGuide: BitFlag;
    lineupInfo: BitFlag;
    recordProgram: BitFlag;
}>>
base: undefined
commands: {
    cancelRecordProgram: Command<TypeFromFields<{
        data: OptionalFieldType<Uint8Array>;
        externalIdList: OptionalFieldType<TypeFromFields<{
            name: FieldType<string>;
            value: FieldType<string>;
        }>[]>;
        programIdentifier: FieldType<string>;
        shouldRecordSeries: FieldType<boolean>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            electronicGuide: boolean;
            recordProgram: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    changeChannel: Command<TypeFromFields<{
        match: FieldType<string>;
    }>, TypeFromFields<{
        data: OptionalFieldType<string>;
        status: FieldType<Channel.Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            channelList: boolean;
        }, {
            lineupInfo: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    changeChannelByNumber: Command<TypeFromFields<{
        majorNumber: FieldType<number>;
        minorNumber: FieldType<number>;
    }>, void, any>;
    getProgramGuide: Command<TypeFromFields<{
        channelList: OptionalFieldType<TypeFromFields<{
            affiliateCallSign: OptionalFieldType<string>;
            callSign: OptionalFieldType<string>;
            identifier: OptionalFieldType<string>;
            majorNumber: FieldType<number>;
            minorNumber: FieldType<number>;
            name: OptionalFieldType<string>;
            type: OptionalFieldType<Channel.ChannelType>;
        }>[]>;
        data: OptionalFieldType<Uint8Array>;
        endTime: FieldType<number>;
        externalIdList: OptionalFieldType<TypeFromFields<{
            name: FieldType<string>;
            value: FieldType<string>;
        }>[]>;
        pageToken: OptionalFieldType<null | TypeFromFields<{
            after: OptionalFieldType<string>;
            before: OptionalFieldType<string>;
            limit: OptionalFieldType<number>;
        }>>;
        recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<{
            recorded: BitFlag;
            recordSeries: BitFlag;
            scheduled: BitFlag;
        }>>;
        startTime: FieldType<number>;
    }>, TypeFromFields<{
        paging: FieldType<TypeFromFields<{
            nextToken: OptionalFieldType<null | TypeFromFields<(...)>>;
            previousToken: OptionalFieldType<null | TypeFromFields<(...)>>;
        }>>;
        programList: FieldType<TypeFromFields<{
            audioLanguages: OptionalFieldType<(...)[]>;
            castList: OptionalFieldType<(...)[]>;
            categoryList: OptionalFieldType<(...)[]>;
            channel: FieldType<TypeFromFields<(...)>>;
            description: OptionalFieldType<string>;
            dvbiUrl: OptionalFieldType<string>;
            endTime: FieldType<number>;
            externalIdList: OptionalFieldType<(...)[]>;
            identifier: FieldType<string>;
            parentalGuidanceText: OptionalFieldType<string>;
            posterArtUrl: OptionalFieldType<string>;
            ratings: OptionalFieldType<(...)[]>;
            recordingFlag: OptionalFieldType<TypeFromPartialBitSchema<(...)>>;
            releaseDate: OptionalFieldType<string>;
            seriesInfo: OptionalFieldType<(...) | (...)>;
            startTime: FieldType<number>;
            subtitle: OptionalFieldType<string>;
            thumbnailUrl: OptionalFieldType<string>;
            title: FieldType<string>;
        }>[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            electronicGuide: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    recordProgram: Command<TypeFromFields<{
        data: OptionalFieldType<Uint8Array>;
        externalIdList: OptionalFieldType<TypeFromFields<{
            name: FieldType<string>;
            value: FieldType<string>;
        }>[]>;
        programIdentifier: FieldType<string>;
        shouldRecordSeries: FieldType<boolean>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            electronicGuide: boolean;
            recordProgram: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    skipChannel: Command<TypeFromFields<{
        count: FieldType<number>;
    }>, void, any>;
}

Type declaration

events: {}
extensions: undefined
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: Branded<Branded<1284, "ClusterId">, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              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> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              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>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  channelList: BitFlag;
                  electronicGuide: BitFlag;
                  lineupInfo: BitFlag;
                  recordProgram: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              lineup: Attribute<null | TypeFromFields<{
                  lineupInfoType: FieldType<Mso>;
                  lineupName: OptionalFieldType<string>;
                  operatorName: FieldType<string>;
                  postalCode: OptionalFieldType<string>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelRecordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannel: Command<TypeFromFields<{
                  match: FieldType<string>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<Channel.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }, {
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              getProgramGuide: Command<TypeFromFields<{
                  channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  data: OptionalFieldType<Uint8Array>;
                  endTime: FieldType<number>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                  recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                  startTime: FieldType<number>;
              }>, TypeFromFields<{
                  paging: FieldType<TypeFromFields<{
                      nextToken: ...;
                      previousToken: ...;
                  }>>;
                  programList: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              recordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: Branded<1284, "ClusterId">;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            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>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                channelList: BitFlag;
                electronicGuide: BitFlag;
                lineupInfo: BitFlag;
                recordProgram: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            lineup: Attribute<null | TypeFromFields<{
                lineupInfoType: FieldType<Mso>;
                lineupName: OptionalFieldType<string>;
                operatorName: FieldType<string>;
                postalCode: OptionalFieldType<string>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelRecordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }, {
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            getProgramGuide: Command<TypeFromFields<{
                channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                data: OptionalFieldType<Uint8Array>;
                endTime: FieldType<number>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                startTime: FieldType<number>;
            }>, TypeFromFields<{
                paging: FieldType<TypeFromFields<{
                    nextToken: ...;
                    previousToken: ...;
                }>>;
                programList: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            recordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: Branded<1284, "ClusterId">;
        name: "Channel";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              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> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              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>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  channelList: BitFlag;
                  electronicGuide: BitFlag;
                  lineupInfo: BitFlag;
                  recordProgram: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              lineup: Attribute<null | TypeFromFields<{
                  lineupInfoType: FieldType<Mso>;
                  lineupName: OptionalFieldType<string>;
                  operatorName: FieldType<string>;
                  postalCode: OptionalFieldType<string>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelRecordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannel: Command<TypeFromFields<{
                  match: FieldType<string>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<Channel.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }, {
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              getProgramGuide: Command<TypeFromFields<{
                  channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  data: OptionalFieldType<Uint8Array>;
                  endTime: FieldType<number>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                  recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                  startTime: FieldType<number>;
              }>, TypeFromFields<{
                  paging: FieldType<TypeFromFields<{
                      nextToken: ...;
                      previousToken: ...;
                  }>>;
                  programList: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              recordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: Branded<1284, "ClusterId">;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            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>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                channelList: BitFlag;
                electronicGuide: BitFlag;
                lineupInfo: BitFlag;
                recordProgram: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            lineup: Attribute<null | TypeFromFields<{
                lineupInfoType: FieldType<Mso>;
                lineupName: OptionalFieldType<string>;
                operatorName: FieldType<string>;
                postalCode: OptionalFieldType<string>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelRecordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }, {
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            getProgramGuide: Command<TypeFromFields<{
                channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                data: OptionalFieldType<Uint8Array>;
                endTime: FieldType<number>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                startTime: FieldType<number>;
            }>, TypeFromFields<{
                paging: FieldType<TypeFromFields<{
                    nextToken: ...;
                    previousToken: ...;
                }>>;
                programList: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            recordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: Branded<1284, "ClusterId">;
        name: "Channel";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          channelList?: {
              affiliateCallSign?: string;
              callSign?: string;
              identifier?: string;
              majorNumber: number;
              minorNumber: number;
              name?: string;
              type?: number;
          }[];
          currentChannel?: null | {
              affiliateCallSign?: string;
              callSign?: string;
              identifier?: string;
              majorNumber: number;
              minorNumber: number;
              name?: string;
              type?: number;
          };
          lineup?: null | {
              lineupInfoType: number;
              lineupName?: string;
              operatorName: string;
              postalCode?: string;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            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>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                channelList: BitFlag;
                electronicGuide: BitFlag;
                lineupInfo: BitFlag;
                recordProgram: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            lineup: Attribute<null | TypeFromFields<{
                lineupInfoType: FieldType<Mso>;
                lineupName: OptionalFieldType<string>;
                operatorName: FieldType<string>;
                postalCode: OptionalFieldType<string>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelRecordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }, {
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            getProgramGuide: Command<TypeFromFields<{
                channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                data: OptionalFieldType<Uint8Array>;
                endTime: FieldType<number>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                startTime: FieldType<number>;
            }>, TypeFromFields<{
                paging: FieldType<TypeFromFields<{
                    nextToken: ...;
                    previousToken: ...;
                }>>;
                programList: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            recordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: Branded<1284, "ClusterId">;
        name: "Channel";
        revision: 2;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              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> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clusterRevision: Attribute<number, never>;
              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>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  channelList: BitFlag;
                  electronicGuide: BitFlag;
                  lineupInfo: BitFlag;
                  recordProgram: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              lineup: Attribute<null | TypeFromFields<{
                  lineupInfoType: FieldType<Mso>;
                  lineupName: OptionalFieldType<string>;
                  operatorName: FieldType<string>;
                  postalCode: OptionalFieldType<string>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              cancelRecordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannel: Command<TypeFromFields<{
                  match: FieldType<string>;
              }>, TypeFromFields<{
                  data: OptionalFieldType<string>;
                  status: FieldType<Channel.Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      channelList: boolean;
                  }, {
                      lineupInfo: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              changeChannelByNumber: Command<TypeFromFields<{
                  majorNumber: FieldType<number>;
                  minorNumber: FieldType<number>;
              }>, void, any>;
              getProgramGuide: Command<TypeFromFields<{
                  channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  data: OptionalFieldType<Uint8Array>;
                  endTime: FieldType<number>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                  recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                  startTime: FieldType<number>;
              }>, TypeFromFields<{
                  paging: FieldType<TypeFromFields<{
                      nextToken: ...;
                      previousToken: ...;
                  }>>;
                  programList: FieldType<TypeFromFields<(...)>[]>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              recordProgram: Command<TypeFromFields<{
                  data: OptionalFieldType<Uint8Array>;
                  externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                  programIdentifier: FieldType<string>;
                  shouldRecordSeries: FieldType<boolean>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      electronicGuide: boolean;
                      recordProgram: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              skipChannel: Command<TypeFromFields<{
                  count: FieldType<number>;
              }>, void, any>;
          };
          features: {
              channelList: BitFlag;
              electronicGuide: BitFlag;
              lineupInfo: BitFlag;
              recordProgram: BitFlag;
          };
          id: Branded<1284, "ClusterId">;
          name: "Channel";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            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> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            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>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                channelList: BitFlag;
                electronicGuide: BitFlag;
                lineupInfo: BitFlag;
                recordProgram: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            lineup: Attribute<null | TypeFromFields<{
                lineupInfoType: FieldType<Mso>;
                lineupName: OptionalFieldType<string>;
                operatorName: FieldType<string>;
                postalCode: OptionalFieldType<string>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            cancelRecordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannel: Command<TypeFromFields<{
                match: FieldType<string>;
            }>, TypeFromFields<{
                data: OptionalFieldType<string>;
                status: FieldType<Channel.Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    channelList: boolean;
                }, {
                    lineupInfo: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            changeChannelByNumber: Command<TypeFromFields<{
                majorNumber: FieldType<number>;
                minorNumber: FieldType<number>;
            }>, void, any>;
            getProgramGuide: Command<TypeFromFields<{
                channelList: OptionalFieldType<TypeFromFields<(...)>[]>;
                data: OptionalFieldType<Uint8Array>;
                endTime: FieldType<number>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                pageToken: OptionalFieldType<null | TypeFromFields<(...)>>;
                recordingFlag: OptionalFieldType<null | TypeFromPartialBitSchema<(...)>>;
                startTime: FieldType<number>;
            }>, TypeFromFields<{
                paging: FieldType<TypeFromFields<{
                    nextToken: ...;
                    previousToken: ...;
                }>>;
                programList: FieldType<TypeFromFields<(...)>[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            recordProgram: Command<TypeFromFields<{
                data: OptionalFieldType<Uint8Array>;
                externalIdList: OptionalFieldType<TypeFromFields<(...)>[]>;
                programIdentifier: FieldType<string>;
                shouldRecordSeries: FieldType<boolean>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    electronicGuide: boolean;
                    recordProgram: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            skipChannel: Command<TypeFromFields<{
                count: FieldType<number>;
            }>, void, any>;
        };
        features: {
            channelList: BitFlag;
            electronicGuide: BitFlag;
            lineupInfo: BitFlag;
            recordProgram: BitFlag;
        };
        id: Branded<1284, "ClusterId">;
        name: "Channel";
        revision: 2;
    }>, SelectionT>