@li0ard/widevine 0.1.0

package/dist/protos/license_protocol.d.ts

@@ -0,0 +1,1664 @@
+/**
+ * Generated by the protoc-gen-ts.  DO NOT EDIT!
+ * compiler version: 6.30.2
+ * source: license_protocol.proto
+ * git: https://github.com/thesayyn/protoc-gen-ts */
+import * as pb_1 from "google-protobuf";
+export declare namespace pywidevine_license_protocol {
+    enum LicenseType {
+        STREAMING = 1,
+        OFFLINE = 2,
+        AUTOMATIC = 3
+    }
+    enum PlatformVerificationStatus {
+        PLATFORM_UNVERIFIED = 0,
+        PLATFORM_TAMPERED = 1,
+        PLATFORM_SOFTWARE_VERIFIED = 2,
+        PLATFORM_HARDWARE_VERIFIED = 3,
+        PLATFORM_NO_VERIFICATION = 4,
+        PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5
+    }
+    enum ProtocolVersion {
+        VERSION_2_0 = 20,
+        VERSION_2_1 = 21,
+        VERSION_2_2 = 22
+    }
+    enum HashAlgorithmProto {
+        HASH_ALGORITHM_UNSPECIFIED = 0,
+        HASH_ALGORITHM_SHA_1 = 1,
+        HASH_ALGORITHM_SHA_256 = 2,
+        HASH_ALGORITHM_SHA_384 = 3
+    }
+    class LicenseIdentification extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            request_id?: Uint8Array;
+            session_id?: Uint8Array;
+            purchase_id?: Uint8Array;
+            type?: LicenseType;
+            version?: number;
+            provider_session_token?: Uint8Array;
+        });
+        get request_id(): Uint8Array;
+        set request_id(value: Uint8Array);
+        get has_request_id(): boolean;
+        get session_id(): Uint8Array;
+        set session_id(value: Uint8Array);
+        get has_session_id(): boolean;
+        get purchase_id(): Uint8Array;
+        set purchase_id(value: Uint8Array);
+        get has_purchase_id(): boolean;
+        get type(): LicenseType;
+        set type(value: LicenseType);
+        get has_type(): boolean;
+        get version(): number;
+        set version(value: number);
+        get has_version(): boolean;
+        get provider_session_token(): Uint8Array;
+        set provider_session_token(value: Uint8Array);
+        get has_provider_session_token(): boolean;
+        static fromObject(data: {
+            request_id?: Uint8Array;
+            session_id?: Uint8Array;
+            purchase_id?: Uint8Array;
+            type?: LicenseType;
+            version?: number;
+            provider_session_token?: Uint8Array;
+        }): LicenseIdentification;
+        toObject(): {
+            request_id?: Uint8Array;
+            session_id?: Uint8Array;
+            purchase_id?: Uint8Array;
+            type?: LicenseType;
+            version?: number;
+            provider_session_token?: Uint8Array;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): LicenseIdentification;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): LicenseIdentification;
+    }
+    class License extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            id?: LicenseIdentification;
+            policy?: License.Policy;
+            key: License.KeyContainer[];
+            license_start_time?: number;
+            remote_attestation_verified?: boolean;
+            provider_client_token?: Uint8Array;
+            protection_scheme?: number;
+            srm_requirement?: Uint8Array;
+            srm_update?: Uint8Array;
+            platform_verification_status?: PlatformVerificationStatus;
+            group_ids: Uint8Array[];
+        });
+        get id(): LicenseIdentification;
+        set id(value: LicenseIdentification);
+        get has_id(): boolean;
+        get policy(): License.Policy;
+        set policy(value: License.Policy);
+        get has_policy(): boolean;
+        get key(): License.KeyContainer[];
+        set key(value: License.KeyContainer[]);
+        get license_start_time(): number;
+        set license_start_time(value: number);
+        get has_license_start_time(): boolean;
+        get remote_attestation_verified(): boolean;
+        set remote_attestation_verified(value: boolean);
+        get has_remote_attestation_verified(): boolean;
+        get provider_client_token(): Uint8Array;
+        set provider_client_token(value: Uint8Array);
+        get has_provider_client_token(): boolean;
+        get protection_scheme(): number;
+        set protection_scheme(value: number);
+        get has_protection_scheme(): boolean;
+        get srm_requirement(): Uint8Array;
+        set srm_requirement(value: Uint8Array);
+        get has_srm_requirement(): boolean;
+        get srm_update(): Uint8Array;
+        set srm_update(value: Uint8Array);
+        get has_srm_update(): boolean;
+        get platform_verification_status(): PlatformVerificationStatus;
+        set platform_verification_status(value: PlatformVerificationStatus);
+        get has_platform_verification_status(): boolean;
+        get group_ids(): Uint8Array[];
+        set group_ids(value: Uint8Array[]);
+        static fromObject(data: {
+            id?: ReturnType<typeof LicenseIdentification.prototype.toObject>;
+            policy?: ReturnType<typeof License.Policy.prototype.toObject>;
+            key?: ReturnType<typeof License.KeyContainer.prototype.toObject>[];
+            license_start_time?: number;
+            remote_attestation_verified?: boolean;
+            provider_client_token?: Uint8Array;
+            protection_scheme?: number;
+            srm_requirement?: Uint8Array;
+            srm_update?: Uint8Array;
+            platform_verification_status?: PlatformVerificationStatus;
+            group_ids: Uint8Array[];
+        }): License;
+        toObject(): {
+            id?: ReturnType<typeof LicenseIdentification.prototype.toObject>;
+            policy?: ReturnType<typeof License.Policy.prototype.toObject>;
+            key?: ReturnType<typeof License.KeyContainer.prototype.toObject>[];
+            license_start_time?: number;
+            remote_attestation_verified?: boolean;
+            provider_client_token?: Uint8Array;
+            protection_scheme?: number;
+            srm_requirement?: Uint8Array;
+            srm_update?: Uint8Array;
+            platform_verification_status?: PlatformVerificationStatus;
+            group_ids: Uint8Array[];
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): License;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): License;
+    }
+    namespace License {
+        class Policy extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                can_play?: boolean;
+                can_persist?: boolean;
+                can_renew?: boolean;
+                rental_duration_seconds?: number;
+                playback_duration_seconds?: number;
+                license_duration_seconds?: number;
+                renewal_recovery_duration_seconds?: number;
+                renewal_server_url?: string;
+                renewal_delay_seconds?: number;
+                renewal_retry_interval_seconds?: number;
+                renew_with_usage?: boolean;
+                always_include_client_id?: boolean;
+                play_start_grace_period_seconds?: number;
+                soft_enforce_playback_duration?: boolean;
+                soft_enforce_rental_duration?: boolean;
+            });
+            get can_play(): boolean;
+            set can_play(value: boolean);
+            get has_can_play(): boolean;
+            get can_persist(): boolean;
+            set can_persist(value: boolean);
+            get has_can_persist(): boolean;
+            get can_renew(): boolean;
+            set can_renew(value: boolean);
+            get has_can_renew(): boolean;
+            get rental_duration_seconds(): number;
+            set rental_duration_seconds(value: number);
+            get has_rental_duration_seconds(): boolean;
+            get playback_duration_seconds(): number;
+            set playback_duration_seconds(value: number);
+            get has_playback_duration_seconds(): boolean;
+            get license_duration_seconds(): number;
+            set license_duration_seconds(value: number);
+            get has_license_duration_seconds(): boolean;
+            get renewal_recovery_duration_seconds(): number;
+            set renewal_recovery_duration_seconds(value: number);
+            get has_renewal_recovery_duration_seconds(): boolean;
+            get renewal_server_url(): string;
+            set renewal_server_url(value: string);
+            get has_renewal_server_url(): boolean;
+            get renewal_delay_seconds(): number;
+            set renewal_delay_seconds(value: number);
+            get has_renewal_delay_seconds(): boolean;
+            get renewal_retry_interval_seconds(): number;
+            set renewal_retry_interval_seconds(value: number);
+            get has_renewal_retry_interval_seconds(): boolean;
+            get renew_with_usage(): boolean;
+            set renew_with_usage(value: boolean);
+            get has_renew_with_usage(): boolean;
+            get always_include_client_id(): boolean;
+            set always_include_client_id(value: boolean);
+            get has_always_include_client_id(): boolean;
+            get play_start_grace_period_seconds(): number;
+            set play_start_grace_period_seconds(value: number);
+            get has_play_start_grace_period_seconds(): boolean;
+            get soft_enforce_playback_duration(): boolean;
+            set soft_enforce_playback_duration(value: boolean);
+            get has_soft_enforce_playback_duration(): boolean;
+            get soft_enforce_rental_duration(): boolean;
+            set soft_enforce_rental_duration(value: boolean);
+            get has_soft_enforce_rental_duration(): boolean;
+            static fromObject(data: {
+                can_play?: boolean;
+                can_persist?: boolean;
+                can_renew?: boolean;
+                rental_duration_seconds?: number;
+                playback_duration_seconds?: number;
+                license_duration_seconds?: number;
+                renewal_recovery_duration_seconds?: number;
+                renewal_server_url?: string;
+                renewal_delay_seconds?: number;
+                renewal_retry_interval_seconds?: number;
+                renew_with_usage?: boolean;
+                always_include_client_id?: boolean;
+                play_start_grace_period_seconds?: number;
+                soft_enforce_playback_duration?: boolean;
+                soft_enforce_rental_duration?: boolean;
+            }): Policy;
+            toObject(): {
+                can_play?: boolean;
+                can_persist?: boolean;
+                can_renew?: boolean;
+                rental_duration_seconds?: number;
+                playback_duration_seconds?: number;
+                license_duration_seconds?: number;
+                renewal_recovery_duration_seconds?: number;
+                renewal_server_url?: string;
+                renewal_delay_seconds?: number;
+                renewal_retry_interval_seconds?: number;
+                renew_with_usage?: boolean;
+                always_include_client_id?: boolean;
+                play_start_grace_period_seconds?: number;
+                soft_enforce_playback_duration?: boolean;
+                soft_enforce_rental_duration?: boolean;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Policy;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): Policy;
+        }
+        class KeyContainer extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                id?: Uint8Array;
+                iv?: Uint8Array;
+                key?: Uint8Array;
+                type?: License.KeyContainer.KeyType;
+                level?: License.KeyContainer.SecurityLevel;
+                required_protection?: License.KeyContainer.OutputProtection;
+                requested_protection?: License.KeyContainer.OutputProtection;
+                key_control?: License.KeyContainer.KeyControl;
+                operator_session_key_permissions?: License.KeyContainer.OperatorSessionKeyPermissions;
+                video_resolution_constraints: License.KeyContainer.VideoResolutionConstraint[];
+                anti_rollback_usage_table?: boolean;
+                track_label?: string;
+            });
+            get id(): Uint8Array;
+            set id(value: Uint8Array);
+            get has_id(): boolean;
+            get iv(): Uint8Array;
+            set iv(value: Uint8Array);
+            get has_iv(): boolean;
+            get key(): Uint8Array;
+            set key(value: Uint8Array);
+            get has_key(): boolean;
+            get type(): License.KeyContainer.KeyType;
+            set type(value: License.KeyContainer.KeyType);
+            get has_type(): boolean;
+            get level(): License.KeyContainer.SecurityLevel;
+            set level(value: License.KeyContainer.SecurityLevel);
+            get has_level(): boolean;
+            get required_protection(): License.KeyContainer.OutputProtection;
+            set required_protection(value: License.KeyContainer.OutputProtection);
+            get has_required_protection(): boolean;
+            get requested_protection(): License.KeyContainer.OutputProtection;
+            set requested_protection(value: License.KeyContainer.OutputProtection);
+            get has_requested_protection(): boolean;
+            get key_control(): License.KeyContainer.KeyControl;
+            set key_control(value: License.KeyContainer.KeyControl);
+            get has_key_control(): boolean;
+            get operator_session_key_permissions(): License.KeyContainer.OperatorSessionKeyPermissions;
+            set operator_session_key_permissions(value: License.KeyContainer.OperatorSessionKeyPermissions);
+            get has_operator_session_key_permissions(): boolean;
+            get video_resolution_constraints(): License.KeyContainer.VideoResolutionConstraint[];
+            set video_resolution_constraints(value: License.KeyContainer.VideoResolutionConstraint[]);
+            get anti_rollback_usage_table(): boolean;
+            set anti_rollback_usage_table(value: boolean);
+            get has_anti_rollback_usage_table(): boolean;
+            get track_label(): string;
+            set track_label(value: string);
+            get has_track_label(): boolean;
+            static fromObject(data: {
+                id?: Uint8Array;
+                iv?: Uint8Array;
+                key?: Uint8Array;
+                type?: License.KeyContainer.KeyType;
+                level?: License.KeyContainer.SecurityLevel;
+                required_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                requested_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                key_control?: ReturnType<typeof License.KeyContainer.KeyControl.prototype.toObject>;
+                operator_session_key_permissions?: ReturnType<typeof License.KeyContainer.OperatorSessionKeyPermissions.prototype.toObject>;
+                video_resolution_constraints?: ReturnType<typeof License.KeyContainer.VideoResolutionConstraint.prototype.toObject>[];
+                anti_rollback_usage_table?: boolean;
+                track_label?: string;
+            }): KeyContainer;
+            toObject(): {
+                id?: Uint8Array;
+                iv?: Uint8Array;
+                key?: Uint8Array;
+                type?: License.KeyContainer.KeyType;
+                level?: License.KeyContainer.SecurityLevel;
+                required_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                requested_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                key_control?: ReturnType<typeof License.KeyContainer.KeyControl.prototype.toObject>;
+                operator_session_key_permissions?: ReturnType<typeof License.KeyContainer.OperatorSessionKeyPermissions.prototype.toObject>;
+                video_resolution_constraints?: ReturnType<typeof License.KeyContainer.VideoResolutionConstraint.prototype.toObject>[];
+                anti_rollback_usage_table?: boolean;
+                track_label?: string;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): KeyContainer;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): KeyContainer;
+        }
+        namespace KeyContainer {
+            enum KeyType {
+                SIGNING = 1,
+                CONTENT = 2,
+                KEY_CONTROL = 3,
+                OPERATOR_SESSION = 4,
+                ENTITLEMENT = 5,
+                OEM_CONTENT = 6
+            }
+            enum SecurityLevel {
+                SW_SECURE_CRYPTO = 1,
+                SW_SECURE_DECODE = 2,
+                HW_SECURE_CRYPTO = 3,
+                HW_SECURE_DECODE = 4,
+                HW_SECURE_ALL = 5
+            }
+            class KeyControl extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    key_control_block?: Uint8Array;
+                    iv?: Uint8Array;
+                });
+                get key_control_block(): Uint8Array;
+                set key_control_block(value: Uint8Array);
+                get has_key_control_block(): boolean;
+                get iv(): Uint8Array;
+                set iv(value: Uint8Array);
+                get has_iv(): boolean;
+                static fromObject(data: {
+                    key_control_block?: Uint8Array;
+                    iv?: Uint8Array;
+                }): KeyControl;
+                toObject(): {
+                    key_control_block?: Uint8Array;
+                    iv?: Uint8Array;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): KeyControl;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): KeyControl;
+            }
+            class OutputProtection extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    hdcp?: License.KeyContainer.OutputProtection.HDCP;
+                    cgms_flags?: License.KeyContainer.OutputProtection.CGMS;
+                    hdcp_srm_rule?: License.KeyContainer.OutputProtection.HdcpSrmRule;
+                    disable_analog_output?: boolean;
+                    disable_digital_output?: boolean;
+                });
+                get hdcp(): License.KeyContainer.OutputProtection.HDCP;
+                set hdcp(value: License.KeyContainer.OutputProtection.HDCP);
+                get has_hdcp(): boolean;
+                get cgms_flags(): License.KeyContainer.OutputProtection.CGMS;
+                set cgms_flags(value: License.KeyContainer.OutputProtection.CGMS);
+                get has_cgms_flags(): boolean;
+                get hdcp_srm_rule(): License.KeyContainer.OutputProtection.HdcpSrmRule;
+                set hdcp_srm_rule(value: License.KeyContainer.OutputProtection.HdcpSrmRule);
+                get has_hdcp_srm_rule(): boolean;
+                get disable_analog_output(): boolean;
+                set disable_analog_output(value: boolean);
+                get has_disable_analog_output(): boolean;
+                get disable_digital_output(): boolean;
+                set disable_digital_output(value: boolean);
+                get has_disable_digital_output(): boolean;
+                static fromObject(data: {
+                    hdcp?: License.KeyContainer.OutputProtection.HDCP;
+                    cgms_flags?: License.KeyContainer.OutputProtection.CGMS;
+                    hdcp_srm_rule?: License.KeyContainer.OutputProtection.HdcpSrmRule;
+                    disable_analog_output?: boolean;
+                    disable_digital_output?: boolean;
+                }): OutputProtection;
+                toObject(): {
+                    hdcp?: License.KeyContainer.OutputProtection.HDCP;
+                    cgms_flags?: License.KeyContainer.OutputProtection.CGMS;
+                    hdcp_srm_rule?: License.KeyContainer.OutputProtection.HdcpSrmRule;
+                    disable_analog_output?: boolean;
+                    disable_digital_output?: boolean;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): OutputProtection;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): OutputProtection;
+            }
+            namespace OutputProtection {
+                enum HDCP {
+                    HDCP_NONE = 0,
+                    HDCP_V1 = 1,
+                    HDCP_V2 = 2,
+                    HDCP_V2_1 = 3,
+                    HDCP_V2_2 = 4,
+                    HDCP_V2_3 = 5,
+                    HDCP_NO_DIGITAL_OUTPUT = 255
+                }
+                enum CGMS {
+                    CGMS_NONE = 42,
+                    COPY_FREE = 0,
+                    COPY_ONCE = 2,
+                    COPY_NEVER = 3
+                }
+                enum HdcpSrmRule {
+                    HDCP_SRM_RULE_NONE = 0,
+                    CURRENT_SRM = 1
+                }
+            }
+            class VideoResolutionConstraint extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    min_resolution_pixels?: number;
+                    max_resolution_pixels?: number;
+                    required_protection?: License.KeyContainer.OutputProtection;
+                });
+                get min_resolution_pixels(): number;
+                set min_resolution_pixels(value: number);
+                get has_min_resolution_pixels(): boolean;
+                get max_resolution_pixels(): number;
+                set max_resolution_pixels(value: number);
+                get has_max_resolution_pixels(): boolean;
+                get required_protection(): License.KeyContainer.OutputProtection;
+                set required_protection(value: License.KeyContainer.OutputProtection);
+                get has_required_protection(): boolean;
+                static fromObject(data: {
+                    min_resolution_pixels?: number;
+                    max_resolution_pixels?: number;
+                    required_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                }): VideoResolutionConstraint;
+                toObject(): {
+                    min_resolution_pixels?: number;
+                    max_resolution_pixels?: number;
+                    required_protection?: ReturnType<typeof License.KeyContainer.OutputProtection.prototype.toObject>;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): VideoResolutionConstraint;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): VideoResolutionConstraint;
+            }
+            class OperatorSessionKeyPermissions extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    allow_encrypt?: boolean;
+                    allow_decrypt?: boolean;
+                    allow_sign?: boolean;
+                    allow_signature_verify?: boolean;
+                });
+                get allow_encrypt(): boolean;
+                set allow_encrypt(value: boolean);
+                get has_allow_encrypt(): boolean;
+                get allow_decrypt(): boolean;
+                set allow_decrypt(value: boolean);
+                get has_allow_decrypt(): boolean;
+                get allow_sign(): boolean;
+                set allow_sign(value: boolean);
+                get has_allow_sign(): boolean;
+                get allow_signature_verify(): boolean;
+                set allow_signature_verify(value: boolean);
+                get has_allow_signature_verify(): boolean;
+                static fromObject(data: {
+                    allow_encrypt?: boolean;
+                    allow_decrypt?: boolean;
+                    allow_sign?: boolean;
+                    allow_signature_verify?: boolean;
+                }): OperatorSessionKeyPermissions;
+                toObject(): {
+                    allow_encrypt?: boolean;
+                    allow_decrypt?: boolean;
+                    allow_sign?: boolean;
+                    allow_signature_verify?: boolean;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): OperatorSessionKeyPermissions;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): OperatorSessionKeyPermissions;
+            }
+        }
+    }
+    class LicenseRequest extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            client_id?: ClientIdentification;
+            content_id?: LicenseRequest.ContentIdentification;
+            type?: LicenseRequest.RequestType;
+            request_time?: number;
+            key_control_nonce_deprecated?: Uint8Array;
+            protocol_version?: ProtocolVersion;
+            key_control_nonce?: number;
+            encrypted_client_id?: EncryptedClientIdentification;
+        });
+        get client_id(): ClientIdentification;
+        set client_id(value: ClientIdentification);
+        get has_client_id(): boolean;
+        get content_id(): LicenseRequest.ContentIdentification;
+        set content_id(value: LicenseRequest.ContentIdentification);
+        get has_content_id(): boolean;
+        get type(): LicenseRequest.RequestType;
+        set type(value: LicenseRequest.RequestType);
+        get has_type(): boolean;
+        get request_time(): number;
+        set request_time(value: number);
+        get has_request_time(): boolean;
+        get key_control_nonce_deprecated(): Uint8Array;
+        set key_control_nonce_deprecated(value: Uint8Array);
+        get has_key_control_nonce_deprecated(): boolean;
+        get protocol_version(): ProtocolVersion;
+        set protocol_version(value: ProtocolVersion);
+        get has_protocol_version(): boolean;
+        get key_control_nonce(): number;
+        set key_control_nonce(value: number);
+        get has_key_control_nonce(): boolean;
+        get encrypted_client_id(): EncryptedClientIdentification;
+        set encrypted_client_id(value: EncryptedClientIdentification);
+        get has_encrypted_client_id(): boolean;
+        static fromObject(data: {
+            client_id?: ReturnType<typeof ClientIdentification.prototype.toObject>;
+            content_id?: ReturnType<typeof LicenseRequest.ContentIdentification.prototype.toObject>;
+            type?: LicenseRequest.RequestType;
+            request_time?: number;
+            key_control_nonce_deprecated?: Uint8Array;
+            protocol_version?: ProtocolVersion;
+            key_control_nonce?: number;
+            encrypted_client_id?: ReturnType<typeof EncryptedClientIdentification.prototype.toObject>;
+        }): LicenseRequest;
+        toObject(): {
+            client_id?: ReturnType<typeof ClientIdentification.prototype.toObject>;
+            content_id?: ReturnType<typeof LicenseRequest.ContentIdentification.prototype.toObject>;
+            type?: LicenseRequest.RequestType;
+            request_time?: number;
+            key_control_nonce_deprecated?: Uint8Array;
+            protocol_version?: ProtocolVersion;
+            key_control_nonce?: number;
+            encrypted_client_id?: ReturnType<typeof EncryptedClientIdentification.prototype.toObject>;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): LicenseRequest;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): LicenseRequest;
+    }
+    namespace LicenseRequest {
+        enum RequestType {
+            NEW = 1,
+            RENEWAL = 2,
+            RELEASE = 3
+        }
+        class ContentIdentification extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | ({} & (({
+                widevine_pssh_data?: LicenseRequest.ContentIdentification.WidevinePsshData;
+                webm_key_id?: never;
+                existing_license?: never;
+                init_data?: never;
+            } | {
+                widevine_pssh_data?: never;
+                webm_key_id?: LicenseRequest.ContentIdentification.WebmKeyId;
+                existing_license?: never;
+                init_data?: never;
+            } | {
+                widevine_pssh_data?: never;
+                webm_key_id?: never;
+                existing_license?: LicenseRequest.ContentIdentification.ExistingLicense;
+                init_data?: never;
+            } | {
+                widevine_pssh_data?: never;
+                webm_key_id?: never;
+                existing_license?: never;
+                init_data?: LicenseRequest.ContentIdentification.InitData;
+            }))));
+            get widevine_pssh_data(): LicenseRequest.ContentIdentification.WidevinePsshData;
+            set widevine_pssh_data(value: LicenseRequest.ContentIdentification.WidevinePsshData);
+            get has_widevine_pssh_data(): boolean;
+            get webm_key_id(): LicenseRequest.ContentIdentification.WebmKeyId;
+            set webm_key_id(value: LicenseRequest.ContentIdentification.WebmKeyId);
+            get has_webm_key_id(): boolean;
+            get existing_license(): LicenseRequest.ContentIdentification.ExistingLicense;
+            set existing_license(value: LicenseRequest.ContentIdentification.ExistingLicense);
+            get has_existing_license(): boolean;
+            get init_data(): LicenseRequest.ContentIdentification.InitData;
+            set init_data(value: LicenseRequest.ContentIdentification.InitData);
+            get has_init_data(): boolean;
+            get content_id_variant(): "none" | "widevine_pssh_data" | "webm_key_id" | "existing_license" | "init_data";
+            static fromObject(data: {
+                widevine_pssh_data?: ReturnType<typeof LicenseRequest.ContentIdentification.WidevinePsshData.prototype.toObject>;
+                webm_key_id?: ReturnType<typeof LicenseRequest.ContentIdentification.WebmKeyId.prototype.toObject>;
+                existing_license?: ReturnType<typeof LicenseRequest.ContentIdentification.ExistingLicense.prototype.toObject>;
+                init_data?: ReturnType<typeof LicenseRequest.ContentIdentification.InitData.prototype.toObject>;
+            }): ContentIdentification;
+            toObject(): {
+                widevine_pssh_data?: ReturnType<typeof LicenseRequest.ContentIdentification.WidevinePsshData.prototype.toObject>;
+                webm_key_id?: ReturnType<typeof LicenseRequest.ContentIdentification.WebmKeyId.prototype.toObject>;
+                existing_license?: ReturnType<typeof LicenseRequest.ContentIdentification.ExistingLicense.prototype.toObject>;
+                init_data?: ReturnType<typeof LicenseRequest.ContentIdentification.InitData.prototype.toObject>;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ContentIdentification;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): ContentIdentification;
+        }
+        namespace ContentIdentification {
+            class WidevinePsshData extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    pssh_data: Uint8Array[];
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                });
+                get pssh_data(): Uint8Array[];
+                set pssh_data(value: Uint8Array[]);
+                get license_type(): LicenseType;
+                set license_type(value: LicenseType);
+                get has_license_type(): boolean;
+                get request_id(): Uint8Array;
+                set request_id(value: Uint8Array);
+                get has_request_id(): boolean;
+                static fromObject(data: {
+                    pssh_data: Uint8Array[];
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                }): WidevinePsshData;
+                toObject(): {
+                    pssh_data: Uint8Array[];
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): WidevinePsshData;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): WidevinePsshData;
+            }
+            class WebmKeyId extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    header?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                });
+                get header(): Uint8Array;
+                set header(value: Uint8Array);
+                get has_header(): boolean;
+                get license_type(): LicenseType;
+                set license_type(value: LicenseType);
+                get has_license_type(): boolean;
+                get request_id(): Uint8Array;
+                set request_id(value: Uint8Array);
+                get has_request_id(): boolean;
+                static fromObject(data: {
+                    header?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                }): WebmKeyId;
+                toObject(): {
+                    header?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): WebmKeyId;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): WebmKeyId;
+            }
+            class ExistingLicense extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    license_id?: LicenseIdentification;
+                    seconds_since_started?: number;
+                    seconds_since_last_played?: number;
+                    session_usage_table_entry?: Uint8Array;
+                });
+                get license_id(): LicenseIdentification;
+                set license_id(value: LicenseIdentification);
+                get has_license_id(): boolean;
+                get seconds_since_started(): number;
+                set seconds_since_started(value: number);
+                get has_seconds_since_started(): boolean;
+                get seconds_since_last_played(): number;
+                set seconds_since_last_played(value: number);
+                get has_seconds_since_last_played(): boolean;
+                get session_usage_table_entry(): Uint8Array;
+                set session_usage_table_entry(value: Uint8Array);
+                get has_session_usage_table_entry(): boolean;
+                static fromObject(data: {
+                    license_id?: ReturnType<typeof LicenseIdentification.prototype.toObject>;
+                    seconds_since_started?: number;
+                    seconds_since_last_played?: number;
+                    session_usage_table_entry?: Uint8Array;
+                }): ExistingLicense;
+                toObject(): {
+                    license_id?: ReturnType<typeof LicenseIdentification.prototype.toObject>;
+                    seconds_since_started?: number;
+                    seconds_since_last_played?: number;
+                    session_usage_table_entry?: Uint8Array;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExistingLicense;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): ExistingLicense;
+            }
+            class InitData extends pb_1.Message {
+                #private;
+                constructor(data?: any[] | {
+                    init_data_type?: LicenseRequest.ContentIdentification.InitData.InitDataType;
+                    init_data?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                });
+                get init_data_type(): LicenseRequest.ContentIdentification.InitData.InitDataType;
+                set init_data_type(value: LicenseRequest.ContentIdentification.InitData.InitDataType);
+                get has_init_data_type(): boolean;
+                get init_data(): Uint8Array;
+                set init_data(value: Uint8Array);
+                get has_init_data(): boolean;
+                get license_type(): LicenseType;
+                set license_type(value: LicenseType);
+                get has_license_type(): boolean;
+                get request_id(): Uint8Array;
+                set request_id(value: Uint8Array);
+                get has_request_id(): boolean;
+                static fromObject(data: {
+                    init_data_type?: LicenseRequest.ContentIdentification.InitData.InitDataType;
+                    init_data?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                }): InitData;
+                toObject(): {
+                    init_data_type?: LicenseRequest.ContentIdentification.InitData.InitDataType;
+                    init_data?: Uint8Array;
+                    license_type?: LicenseType;
+                    request_id?: Uint8Array;
+                };
+                serialize(): Uint8Array;
+                serialize(w: pb_1.BinaryWriter): void;
+                static deserialize(bytes: Uint8Array | pb_1.BinaryReader): InitData;
+                serializeBinary(): Uint8Array;
+                static deserializeBinary(bytes: Uint8Array): InitData;
+            }
+            namespace InitData {
+                enum InitDataType {
+                    CENC = 1,
+                    WEBM = 2
+                }
+            }
+        }
+    }
+    class MetricData extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            stage_name?: string;
+            metric_data: MetricData.TypeValue[];
+        });
+        get stage_name(): string;
+        set stage_name(value: string);
+        get has_stage_name(): boolean;
+        get metric_data(): MetricData.TypeValue[];
+        set metric_data(value: MetricData.TypeValue[]);
+        static fromObject(data: {
+            stage_name?: string;
+            metric_data?: ReturnType<typeof MetricData.TypeValue.prototype.toObject>[];
+        }): MetricData;
+        toObject(): {
+            stage_name?: string;
+            metric_data?: ReturnType<typeof MetricData.TypeValue.prototype.toObject>[];
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MetricData;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): MetricData;
+    }
+    namespace MetricData {
+        enum MetricType {
+            LATENCY = 1,
+            TIMESTAMP = 2
+        }
+        class TypeValue extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                type?: MetricData.MetricType;
+                value?: number;
+            });
+            get type(): MetricData.MetricType;
+            set type(value: MetricData.MetricType);
+            get has_type(): boolean;
+            get value(): number;
+            set value(value: number);
+            get has_value(): boolean;
+            static fromObject(data: {
+                type?: MetricData.MetricType;
+                value?: number;
+            }): TypeValue;
+            toObject(): {
+                type?: MetricData.MetricType;
+                value?: number;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): TypeValue;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): TypeValue;
+        }
+    }
+    class VersionInfo extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            license_sdk_version?: string;
+            license_service_version?: string;
+        });
+        get license_sdk_version(): string;
+        set license_sdk_version(value: string);
+        get has_license_sdk_version(): boolean;
+        get license_service_version(): string;
+        set license_service_version(value: string);
+        get has_license_service_version(): boolean;
+        static fromObject(data: {
+            license_sdk_version?: string;
+            license_service_version?: string;
+        }): VersionInfo;
+        toObject(): {
+            license_sdk_version?: string;
+            license_service_version?: string;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): VersionInfo;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): VersionInfo;
+    }
+    class SignedMessage extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            type?: SignedMessage.MessageType;
+            msg?: Uint8Array;
+            signature?: Uint8Array;
+            session_key?: Uint8Array;
+            remote_attestation?: Uint8Array;
+            metric_data: MetricData[];
+            service_version_info?: VersionInfo;
+            session_key_type?: SignedMessage.SessionKeyType;
+            oemcrypto_core_message?: Uint8Array;
+        });
+        get type(): SignedMessage.MessageType;
+        set type(value: SignedMessage.MessageType);
+        get has_type(): boolean;
+        get msg(): Uint8Array;
+        set msg(value: Uint8Array);
+        get has_msg(): boolean;
+        get signature(): Uint8Array;
+        set signature(value: Uint8Array);
+        get has_signature(): boolean;
+        get session_key(): Uint8Array;
+        set session_key(value: Uint8Array);
+        get has_session_key(): boolean;
+        get remote_attestation(): Uint8Array;
+        set remote_attestation(value: Uint8Array);
+        get has_remote_attestation(): boolean;
+        get metric_data(): MetricData[];
+        set metric_data(value: MetricData[]);
+        get service_version_info(): VersionInfo;
+        set service_version_info(value: VersionInfo);
+        get has_service_version_info(): boolean;
+        get session_key_type(): SignedMessage.SessionKeyType;
+        set session_key_type(value: SignedMessage.SessionKeyType);
+        get has_session_key_type(): boolean;
+        get oemcrypto_core_message(): Uint8Array;
+        set oemcrypto_core_message(value: Uint8Array);
+        get has_oemcrypto_core_message(): boolean;
+        static fromObject(data: {
+            type?: SignedMessage.MessageType;
+            msg?: Uint8Array;
+            signature?: Uint8Array;
+            session_key?: Uint8Array;
+            remote_attestation?: Uint8Array;
+            metric_data?: ReturnType<typeof MetricData.prototype.toObject>[];
+            service_version_info?: ReturnType<typeof VersionInfo.prototype.toObject>;
+            session_key_type?: SignedMessage.SessionKeyType;
+            oemcrypto_core_message?: Uint8Array;
+        }): SignedMessage;
+        toObject(): {
+            type?: SignedMessage.MessageType;
+            msg?: Uint8Array;
+            signature?: Uint8Array;
+            session_key?: Uint8Array;
+            remote_attestation?: Uint8Array;
+            metric_data?: ReturnType<typeof MetricData.prototype.toObject>[];
+            service_version_info?: ReturnType<typeof VersionInfo.prototype.toObject>;
+            session_key_type?: SignedMessage.SessionKeyType;
+            oemcrypto_core_message?: Uint8Array;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): SignedMessage;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): SignedMessage;
+    }
+    namespace SignedMessage {
+        enum MessageType {
+            LICENSE_REQUEST = 1,
+            LICENSE = 2,
+            ERROR_RESPONSE = 3,
+            SERVICE_CERTIFICATE_REQUEST = 4,
+            SERVICE_CERTIFICATE = 5,
+            SUB_LICENSE = 6,
+            CAS_LICENSE_REQUEST = 7,
+            CAS_LICENSE = 8,
+            EXTERNAL_LICENSE_REQUEST = 9,
+            EXTERNAL_LICENSE = 10
+        }
+        enum SessionKeyType {
+            UNDEFINED = 0,
+            WRAPPED_AES_KEY = 1,
+            EPHERMERAL_ECC_PUBLIC_KEY = 2
+        }
+    }
+    class ClientIdentification extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            type?: ClientIdentification.TokenType;
+            token?: Uint8Array;
+            client_info: ClientIdentification.NameValue[];
+            provider_client_token?: Uint8Array;
+            license_counter?: number;
+            client_capabilities?: ClientIdentification.ClientCapabilities;
+            vmp_data?: Uint8Array;
+            device_credentials: ClientIdentification.ClientCredentials[];
+        });
+        get type(): ClientIdentification.TokenType;
+        set type(value: ClientIdentification.TokenType);
+        get has_type(): boolean;
+        get token(): Uint8Array;
+        set token(value: Uint8Array);
+        get has_token(): boolean;
+        get client_info(): ClientIdentification.NameValue[];
+        set client_info(value: ClientIdentification.NameValue[]);
+        get provider_client_token(): Uint8Array;
+        set provider_client_token(value: Uint8Array);
+        get has_provider_client_token(): boolean;
+        get license_counter(): number;
+        set license_counter(value: number);
+        get has_license_counter(): boolean;
+        get client_capabilities(): ClientIdentification.ClientCapabilities;
+        set client_capabilities(value: ClientIdentification.ClientCapabilities);
+        get has_client_capabilities(): boolean;
+        get vmp_data(): Uint8Array;
+        set vmp_data(value: Uint8Array);
+        get has_vmp_data(): boolean;
+        get device_credentials(): ClientIdentification.ClientCredentials[];
+        set device_credentials(value: ClientIdentification.ClientCredentials[]);
+        static fromObject(data: {
+            type?: ClientIdentification.TokenType;
+            token?: Uint8Array;
+            client_info?: ReturnType<typeof ClientIdentification.NameValue.prototype.toObject>[];
+            provider_client_token?: Uint8Array;
+            license_counter?: number;
+            client_capabilities?: ReturnType<typeof ClientIdentification.ClientCapabilities.prototype.toObject>;
+            vmp_data?: Uint8Array;
+            device_credentials?: ReturnType<typeof ClientIdentification.ClientCredentials.prototype.toObject>[];
+        }): ClientIdentification;
+        toObject(): {
+            type?: ClientIdentification.TokenType;
+            token?: Uint8Array;
+            client_info?: ReturnType<typeof ClientIdentification.NameValue.prototype.toObject>[];
+            provider_client_token?: Uint8Array;
+            license_counter?: number;
+            client_capabilities?: ReturnType<typeof ClientIdentification.ClientCapabilities.prototype.toObject>;
+            vmp_data?: Uint8Array;
+            device_credentials?: ReturnType<typeof ClientIdentification.ClientCredentials.prototype.toObject>[];
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ClientIdentification;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): ClientIdentification;
+    }
+    namespace ClientIdentification {
+        enum TokenType {
+            KEYBOX = 0,
+            DRM_DEVICE_CERTIFICATE = 1,
+            REMOTE_ATTESTATION_CERTIFICATE = 2,
+            OEM_DEVICE_CERTIFICATE = 3
+        }
+        class NameValue extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                name?: string;
+                value?: string;
+            });
+            get name(): string;
+            set name(value: string);
+            get has_name(): boolean;
+            get value(): string;
+            set value(value: string);
+            get has_value(): boolean;
+            static fromObject(data: {
+                name?: string;
+                value?: string;
+            }): NameValue;
+            toObject(): {
+                name?: string;
+                value?: string;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NameValue;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): NameValue;
+        }
+        class ClientCapabilities extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                client_token?: boolean;
+                session_token?: boolean;
+                video_resolution_constraints?: boolean;
+                max_hdcp_version?: ClientIdentification.ClientCapabilities.HdcpVersion;
+                oem_crypto_api_version?: number;
+                anti_rollback_usage_table?: boolean;
+                srm_version?: number;
+                can_update_srm?: boolean;
+                supported_certificate_key_type: ClientIdentification.ClientCapabilities.CertificateKeyType[];
+                analog_output_capabilities?: ClientIdentification.ClientCapabilities.AnalogOutputCapabilities;
+                can_disable_analog_output?: boolean;
+                resource_rating_tier?: number;
+            });
+            get client_token(): boolean;
+            set client_token(value: boolean);
+            get has_client_token(): boolean;
+            get session_token(): boolean;
+            set session_token(value: boolean);
+            get has_session_token(): boolean;
+            get video_resolution_constraints(): boolean;
+            set video_resolution_constraints(value: boolean);
+            get has_video_resolution_constraints(): boolean;
+            get max_hdcp_version(): ClientIdentification.ClientCapabilities.HdcpVersion;
+            set max_hdcp_version(value: ClientIdentification.ClientCapabilities.HdcpVersion);
+            get has_max_hdcp_version(): boolean;
+            get oem_crypto_api_version(): number;
+            set oem_crypto_api_version(value: number);
+            get has_oem_crypto_api_version(): boolean;
+            get anti_rollback_usage_table(): boolean;
+            set anti_rollback_usage_table(value: boolean);
+            get has_anti_rollback_usage_table(): boolean;
+            get srm_version(): number;
+            set srm_version(value: number);
+            get has_srm_version(): boolean;
+            get can_update_srm(): boolean;
+            set can_update_srm(value: boolean);
+            get has_can_update_srm(): boolean;
+            get supported_certificate_key_type(): ClientIdentification.ClientCapabilities.CertificateKeyType[];
+            set supported_certificate_key_type(value: ClientIdentification.ClientCapabilities.CertificateKeyType[]);
+            get analog_output_capabilities(): ClientIdentification.ClientCapabilities.AnalogOutputCapabilities;
+            set analog_output_capabilities(value: ClientIdentification.ClientCapabilities.AnalogOutputCapabilities);
+            get has_analog_output_capabilities(): boolean;
+            get can_disable_analog_output(): boolean;
+            set can_disable_analog_output(value: boolean);
+            get has_can_disable_analog_output(): boolean;
+            get resource_rating_tier(): number;
+            set resource_rating_tier(value: number);
+            get has_resource_rating_tier(): boolean;
+            static fromObject(data: {
+                client_token?: boolean;
+                session_token?: boolean;
+                video_resolution_constraints?: boolean;
+                max_hdcp_version?: ClientIdentification.ClientCapabilities.HdcpVersion;
+                oem_crypto_api_version?: number;
+                anti_rollback_usage_table?: boolean;
+                srm_version?: number;
+                can_update_srm?: boolean;
+                supported_certificate_key_type: ClientIdentification.ClientCapabilities.CertificateKeyType[];
+                analog_output_capabilities?: ClientIdentification.ClientCapabilities.AnalogOutputCapabilities;
+                can_disable_analog_output?: boolean;
+                resource_rating_tier?: number;
+            }): ClientCapabilities;
+            toObject(): {
+                client_token?: boolean;
+                session_token?: boolean;
+                video_resolution_constraints?: boolean;
+                max_hdcp_version?: ClientIdentification.ClientCapabilities.HdcpVersion;
+                oem_crypto_api_version?: number;
+                anti_rollback_usage_table?: boolean;
+                srm_version?: number;
+                can_update_srm?: boolean;
+                supported_certificate_key_type: ClientIdentification.ClientCapabilities.CertificateKeyType[];
+                analog_output_capabilities?: ClientIdentification.ClientCapabilities.AnalogOutputCapabilities;
+                can_disable_analog_output?: boolean;
+                resource_rating_tier?: number;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ClientCapabilities;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): ClientCapabilities;
+        }
+        namespace ClientCapabilities {
+            enum HdcpVersion {
+                HDCP_NONE = 0,
+                HDCP_V1 = 1,
+                HDCP_V2 = 2,
+                HDCP_V2_1 = 3,
+                HDCP_V2_2 = 4,
+                HDCP_V2_3 = 5,
+                HDCP_NO_DIGITAL_OUTPUT = 255
+            }
+            enum CertificateKeyType {
+                RSA_2048 = 0,
+                RSA_3072 = 1,
+                ECC_SECP256R1 = 2,
+                ECC_SECP384R1 = 3,
+                ECC_SECP521R1 = 4
+            }
+            enum AnalogOutputCapabilities {
+                ANALOG_OUTPUT_UNKNOWN = 0,
+                ANALOG_OUTPUT_NONE = 1,
+                ANALOG_OUTPUT_SUPPORTED = 2,
+                ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3
+            }
+        }
+        class ClientCredentials extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                type?: ClientIdentification.TokenType;
+                token?: Uint8Array;
+            });
+            get type(): ClientIdentification.TokenType;
+            set type(value: ClientIdentification.TokenType);
+            get has_type(): boolean;
+            get token(): Uint8Array;
+            set token(value: Uint8Array);
+            get has_token(): boolean;
+            static fromObject(data: {
+                type?: ClientIdentification.TokenType;
+                token?: Uint8Array;
+            }): ClientCredentials;
+            toObject(): {
+                type?: ClientIdentification.TokenType;
+                token?: Uint8Array;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ClientCredentials;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): ClientCredentials;
+        }
+    }
+    class EncryptedClientIdentification extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            provider_id?: string;
+            service_certificate_serial_number?: Uint8Array;
+            encrypted_client_id?: Uint8Array;
+            encrypted_client_id_iv?: Uint8Array;
+            encrypted_privacy_key?: Uint8Array;
+        });
+        get provider_id(): string;
+        set provider_id(value: string);
+        get has_provider_id(): boolean;
+        get service_certificate_serial_number(): Uint8Array;
+        set service_certificate_serial_number(value: Uint8Array);
+        get has_service_certificate_serial_number(): boolean;
+        get encrypted_client_id(): Uint8Array;
+        set encrypted_client_id(value: Uint8Array);
+        get has_encrypted_client_id(): boolean;
+        get encrypted_client_id_iv(): Uint8Array;
+        set encrypted_client_id_iv(value: Uint8Array);
+        get has_encrypted_client_id_iv(): boolean;
+        get encrypted_privacy_key(): Uint8Array;
+        set encrypted_privacy_key(value: Uint8Array);
+        get has_encrypted_privacy_key(): boolean;
+        static fromObject(data: {
+            provider_id?: string;
+            service_certificate_serial_number?: Uint8Array;
+            encrypted_client_id?: Uint8Array;
+            encrypted_client_id_iv?: Uint8Array;
+            encrypted_privacy_key?: Uint8Array;
+        }): EncryptedClientIdentification;
+        toObject(): {
+            provider_id?: string;
+            service_certificate_serial_number?: Uint8Array;
+            encrypted_client_id?: Uint8Array;
+            encrypted_client_id_iv?: Uint8Array;
+            encrypted_privacy_key?: Uint8Array;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EncryptedClientIdentification;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): EncryptedClientIdentification;
+    }
+    class DrmCertificate extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            type?: DrmCertificate.Type;
+            serial_number?: Uint8Array;
+            creation_time_seconds?: number;
+            expiration_time_seconds?: number;
+            public_key?: Uint8Array;
+            system_id?: number;
+            /** @deprecated*/
+            test_device_deprecated?: boolean;
+            provider_id?: string;
+            service_types: DrmCertificate.ServiceType[];
+            algorithm?: DrmCertificate.Algorithm;
+            rot_id?: Uint8Array;
+            encryption_key?: DrmCertificate.EncryptionKey;
+        });
+        get type(): DrmCertificate.Type;
+        set type(value: DrmCertificate.Type);
+        get has_type(): boolean;
+        get serial_number(): Uint8Array;
+        set serial_number(value: Uint8Array);
+        get has_serial_number(): boolean;
+        get creation_time_seconds(): number;
+        set creation_time_seconds(value: number);
+        get has_creation_time_seconds(): boolean;
+        get expiration_time_seconds(): number;
+        set expiration_time_seconds(value: number);
+        get has_expiration_time_seconds(): boolean;
+        get public_key(): Uint8Array;
+        set public_key(value: Uint8Array);
+        get has_public_key(): boolean;
+        get system_id(): number;
+        set system_id(value: number);
+        get has_system_id(): boolean;
+        /** @deprecated*/
+        get test_device_deprecated(): boolean;
+        /** @deprecated*/
+        set test_device_deprecated(value: boolean);
+        /** @deprecated*/
+        get has_test_device_deprecated(): boolean;
+        get provider_id(): string;
+        set provider_id(value: string);
+        get has_provider_id(): boolean;
+        get service_types(): DrmCertificate.ServiceType[];
+        set service_types(value: DrmCertificate.ServiceType[]);
+        get algorithm(): DrmCertificate.Algorithm;
+        set algorithm(value: DrmCertificate.Algorithm);
+        get has_algorithm(): boolean;
+        get rot_id(): Uint8Array;
+        set rot_id(value: Uint8Array);
+        get has_rot_id(): boolean;
+        get encryption_key(): DrmCertificate.EncryptionKey;
+        set encryption_key(value: DrmCertificate.EncryptionKey);
+        get has_encryption_key(): boolean;
+        static fromObject(data: {
+            type?: DrmCertificate.Type;
+            serial_number?: Uint8Array;
+            creation_time_seconds?: number;
+            expiration_time_seconds?: number;
+            public_key?: Uint8Array;
+            system_id?: number;
+            test_device_deprecated?: boolean;
+            provider_id?: string;
+            service_types: DrmCertificate.ServiceType[];
+            algorithm?: DrmCertificate.Algorithm;
+            rot_id?: Uint8Array;
+            encryption_key?: ReturnType<typeof DrmCertificate.EncryptionKey.prototype.toObject>;
+        }): DrmCertificate;
+        toObject(): {
+            type?: DrmCertificate.Type;
+            serial_number?: Uint8Array;
+            creation_time_seconds?: number;
+            expiration_time_seconds?: number;
+            public_key?: Uint8Array;
+            system_id?: number;
+            test_device_deprecated?: boolean;
+            provider_id?: string;
+            service_types: DrmCertificate.ServiceType[];
+            algorithm?: DrmCertificate.Algorithm;
+            rot_id?: Uint8Array;
+            encryption_key?: ReturnType<typeof DrmCertificate.EncryptionKey.prototype.toObject>;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DrmCertificate;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): DrmCertificate;
+    }
+    namespace DrmCertificate {
+        enum Type {
+            ROOT = 0,
+            DEVICE_MODEL = 1,
+            DEVICE = 2,
+            SERVICE = 3,
+            PROVISIONER = 4
+        }
+        enum ServiceType {
+            UNKNOWN_SERVICE_TYPE = 0,
+            LICENSE_SERVER_SDK = 1,
+            LICENSE_SERVER_PROXY_SDK = 2,
+            PROVISIONING_SDK = 3,
+            CAS_PROXY_SDK = 4
+        }
+        enum Algorithm {
+            UNKNOWN_ALGORITHM = 0,
+            RSA = 1,
+            ECC_SECP256R1 = 2,
+            ECC_SECP384R1 = 3,
+            ECC_SECP521R1 = 4
+        }
+        class EncryptionKey extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                public_key?: Uint8Array;
+                algorithm?: DrmCertificate.Algorithm;
+            });
+            get public_key(): Uint8Array;
+            set public_key(value: Uint8Array);
+            get has_public_key(): boolean;
+            get algorithm(): DrmCertificate.Algorithm;
+            set algorithm(value: DrmCertificate.Algorithm);
+            get has_algorithm(): boolean;
+            static fromObject(data: {
+                public_key?: Uint8Array;
+                algorithm?: DrmCertificate.Algorithm;
+            }): EncryptionKey;
+            toObject(): {
+                public_key?: Uint8Array;
+                algorithm?: DrmCertificate.Algorithm;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EncryptionKey;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): EncryptionKey;
+        }
+    }
+    class SignedDrmCertificate extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            drm_certificate?: Uint8Array;
+            signature?: Uint8Array;
+            signer?: SignedDrmCertificate;
+            hash_algorithm?: HashAlgorithmProto;
+        });
+        get drm_certificate(): Uint8Array;
+        set drm_certificate(value: Uint8Array);
+        get has_drm_certificate(): boolean;
+        get signature(): Uint8Array;
+        set signature(value: Uint8Array);
+        get has_signature(): boolean;
+        get signer(): SignedDrmCertificate;
+        set signer(value: SignedDrmCertificate);
+        get has_signer(): boolean;
+        get hash_algorithm(): HashAlgorithmProto;
+        set hash_algorithm(value: HashAlgorithmProto);
+        get has_hash_algorithm(): boolean;
+        static fromObject(data: {
+            drm_certificate?: Uint8Array;
+            signature?: Uint8Array;
+            signer?: ReturnType<typeof SignedDrmCertificate.prototype.toObject>;
+            hash_algorithm?: HashAlgorithmProto;
+        }): SignedDrmCertificate;
+        toObject(): {
+            drm_certificate?: Uint8Array;
+            signature?: Uint8Array;
+            signer?: ReturnType<typeof SignedDrmCertificate.prototype.toObject>;
+            hash_algorithm?: HashAlgorithmProto;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): SignedDrmCertificate;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): SignedDrmCertificate;
+    }
+    class WidevinePsshData extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            key_ids: Uint8Array[];
+            content_id?: Uint8Array;
+            crypto_period_index?: number;
+            protection_scheme?: number;
+            crypto_period_seconds?: number;
+            type?: WidevinePsshData.Type;
+            key_sequence?: number;
+            group_ids: Uint8Array[];
+            entitled_keys: WidevinePsshData.EntitledKey[];
+            video_feature?: string;
+            /** @deprecated*/
+            algorithm?: WidevinePsshData.Algorithm;
+            /** @deprecated*/
+            provider?: string;
+            /** @deprecated*/
+            track_type?: string;
+            /** @deprecated*/
+            policy?: string;
+            /** @deprecated*/
+            grouped_license?: Uint8Array;
+        });
+        get key_ids(): Uint8Array[];
+        set key_ids(value: Uint8Array[]);
+        get content_id(): Uint8Array;
+        set content_id(value: Uint8Array);
+        get has_content_id(): boolean;
+        get crypto_period_index(): number;
+        set crypto_period_index(value: number);
+        get has_crypto_period_index(): boolean;
+        get protection_scheme(): number;
+        set protection_scheme(value: number);
+        get has_protection_scheme(): boolean;
+        get crypto_period_seconds(): number;
+        set crypto_period_seconds(value: number);
+        get has_crypto_period_seconds(): boolean;
+        get type(): WidevinePsshData.Type;
+        set type(value: WidevinePsshData.Type);
+        get has_type(): boolean;
+        get key_sequence(): number;
+        set key_sequence(value: number);
+        get has_key_sequence(): boolean;
+        get group_ids(): Uint8Array[];
+        set group_ids(value: Uint8Array[]);
+        get entitled_keys(): WidevinePsshData.EntitledKey[];
+        set entitled_keys(value: WidevinePsshData.EntitledKey[]);
+        get video_feature(): string;
+        set video_feature(value: string);
+        get has_video_feature(): boolean;
+        /** @deprecated*/
+        get algorithm(): WidevinePsshData.Algorithm;
+        /** @deprecated*/
+        set algorithm(value: WidevinePsshData.Algorithm);
+        /** @deprecated*/
+        get has_algorithm(): boolean;
+        /** @deprecated*/
+        get provider(): string;
+        /** @deprecated*/
+        set provider(value: string);
+        /** @deprecated*/
+        get has_provider(): boolean;
+        /** @deprecated*/
+        get track_type(): string;
+        /** @deprecated*/
+        set track_type(value: string);
+        /** @deprecated*/
+        get has_track_type(): boolean;
+        /** @deprecated*/
+        get policy(): string;
+        /** @deprecated*/
+        set policy(value: string);
+        /** @deprecated*/
+        get has_policy(): boolean;
+        /** @deprecated*/
+        get grouped_license(): Uint8Array;
+        /** @deprecated*/
+        set grouped_license(value: Uint8Array);
+        /** @deprecated*/
+        get has_grouped_license(): boolean;
+        static fromObject(data: {
+            key_ids: Uint8Array[];
+            content_id?: Uint8Array;
+            crypto_period_index?: number;
+            protection_scheme?: number;
+            crypto_period_seconds?: number;
+            type?: WidevinePsshData.Type;
+            key_sequence?: number;
+            group_ids: Uint8Array[];
+            entitled_keys?: ReturnType<typeof WidevinePsshData.EntitledKey.prototype.toObject>[];
+            video_feature?: string;
+            algorithm?: WidevinePsshData.Algorithm;
+            provider?: string;
+            track_type?: string;
+            policy?: string;
+            grouped_license?: Uint8Array;
+        }): WidevinePsshData;
+        toObject(): {
+            key_ids: Uint8Array[];
+            content_id?: Uint8Array;
+            crypto_period_index?: number;
+            protection_scheme?: number;
+            crypto_period_seconds?: number;
+            type?: WidevinePsshData.Type;
+            key_sequence?: number;
+            group_ids: Uint8Array[];
+            entitled_keys?: ReturnType<typeof WidevinePsshData.EntitledKey.prototype.toObject>[];
+            video_feature?: string;
+            algorithm?: WidevinePsshData.Algorithm;
+            provider?: string;
+            track_type?: string;
+            policy?: string;
+            grouped_license?: Uint8Array;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): WidevinePsshData;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): WidevinePsshData;
+    }
+    namespace WidevinePsshData {
+        enum Type {
+            SINGLE = 0,
+            ENTITLEMENT = 1,
+            ENTITLED_KEY = 2
+        }
+        enum Algorithm {
+            UNENCRYPTED = 0,
+            AESCTR = 1
+        }
+        class EntitledKey extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                entitlement_key_id?: Uint8Array;
+                key_id?: Uint8Array;
+                key?: Uint8Array;
+                iv?: Uint8Array;
+                entitlement_key_size_bytes?: number;
+            });
+            get entitlement_key_id(): Uint8Array;
+            set entitlement_key_id(value: Uint8Array);
+            get has_entitlement_key_id(): boolean;
+            get key_id(): Uint8Array;
+            set key_id(value: Uint8Array);
+            get has_key_id(): boolean;
+            get key(): Uint8Array;
+            set key(value: Uint8Array);
+            get has_key(): boolean;
+            get iv(): Uint8Array;
+            set iv(value: Uint8Array);
+            get has_iv(): boolean;
+            get entitlement_key_size_bytes(): number;
+            set entitlement_key_size_bytes(value: number);
+            get has_entitlement_key_size_bytes(): boolean;
+            static fromObject(data: {
+                entitlement_key_id?: Uint8Array;
+                key_id?: Uint8Array;
+                key?: Uint8Array;
+                iv?: Uint8Array;
+                entitlement_key_size_bytes?: number;
+            }): EntitledKey;
+            toObject(): {
+                entitlement_key_id?: Uint8Array;
+                key_id?: Uint8Array;
+                key?: Uint8Array;
+                iv?: Uint8Array;
+                entitlement_key_size_bytes?: number;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EntitledKey;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): EntitledKey;
+        }
+    }
+    class FileHashes extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            signer?: Uint8Array;
+            signatures: FileHashes.Signature[];
+        });
+        get signer(): Uint8Array;
+        set signer(value: Uint8Array);
+        get has_signer(): boolean;
+        get signatures(): FileHashes.Signature[];
+        set signatures(value: FileHashes.Signature[]);
+        static fromObject(data: {
+            signer?: Uint8Array;
+            signatures?: ReturnType<typeof FileHashes.Signature.prototype.toObject>[];
+        }): FileHashes;
+        toObject(): {
+            signer?: Uint8Array;
+            signatures?: ReturnType<typeof FileHashes.Signature.prototype.toObject>[];
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FileHashes;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): FileHashes;
+    }
+    namespace FileHashes {
+        class Signature extends pb_1.Message {
+            #private;
+            constructor(data?: any[] | {
+                filename?: string;
+                test_signing?: boolean;
+                SHA512Hash?: Uint8Array;
+                main_exe?: boolean;
+                signature?: Uint8Array;
+            });
+            get filename(): string;
+            set filename(value: string);
+            get has_filename(): boolean;
+            get test_signing(): boolean;
+            set test_signing(value: boolean);
+            get has_test_signing(): boolean;
+            get SHA512Hash(): Uint8Array;
+            set SHA512Hash(value: Uint8Array);
+            get has_SHA512Hash(): boolean;
+            get main_exe(): boolean;
+            set main_exe(value: boolean);
+            get has_main_exe(): boolean;
+            get signature(): Uint8Array;
+            set signature(value: Uint8Array);
+            get has_signature(): boolean;
+            static fromObject(data: {
+                filename?: string;
+                test_signing?: boolean;
+                SHA512Hash?: Uint8Array;
+                main_exe?: boolean;
+                signature?: Uint8Array;
+            }): Signature;
+            toObject(): {
+                filename?: string;
+                test_signing?: boolean;
+                SHA512Hash?: Uint8Array;
+                main_exe?: boolean;
+                signature?: Uint8Array;
+            };
+            serialize(): Uint8Array;
+            serialize(w: pb_1.BinaryWriter): void;
+            static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Signature;
+            serializeBinary(): Uint8Array;
+            static deserializeBinary(bytes: Uint8Array): Signature;
+        }
+    }
+}