import * as $protobuf from "protobufjs";
import Long = require("long");

export interface ITemporaryExposureKeyExport extends TemporaryExposureKeyExport.$Properties {
}

export class TemporaryExposureKeyExport {
    constructor(properties?: TemporaryExposureKeyExport.$Properties);
    $unknowns?: Uint8Array[];
    startTimestamp: (number|Long);
    endTimestamp: (number|Long);
    region: string;
    batchNum: number;
    batchSize: number;
    signatureInfos: SignatureInfo.$Properties[];
    keys: TemporaryExposureKey.$Properties[];
    revisedKeys: TemporaryExposureKey.$Properties[];
    static create(properties: TemporaryExposureKeyExport.$Shape): TemporaryExposureKeyExport & TemporaryExposureKeyExport.$Shape;
    static create(properties?: TemporaryExposureKeyExport.$Properties): TemporaryExposureKeyExport;
    static encode(message: TemporaryExposureKeyExport.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static encodeDelimited(message: TemporaryExposureKeyExport.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TemporaryExposureKeyExport & TemporaryExposureKeyExport.$Shape;
    static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TemporaryExposureKeyExport & TemporaryExposureKeyExport.$Shape;
    static verify(message: { [k: string]: any }): (string|null);
    static fromObject(object: { [k: string]: any }): TemporaryExposureKeyExport;
    static toObject(message: TemporaryExposureKeyExport, options?: $protobuf.IConversionOptions): { [k: string]: any };
    toJSON(): { [k: string]: any };
    static getTypeUrl(prefix?: string): string;
}

export namespace TemporaryExposureKeyExport {
    interface $Properties {
        startTimestamp?: (number|Long|null);
        endTimestamp?: (number|Long|null);
        region?: (string|null);
        batchNum?: (number|null);
        batchSize?: (number|null);
        signatureInfos?: (SignatureInfo.$Properties[]|null);
        keys?: (TemporaryExposureKey.$Properties[]|null);
        revisedKeys?: (TemporaryExposureKey.$Properties[]|null);
        $unknowns?: Uint8Array[];
    }
    type $Shape = TemporaryExposureKeyExport.$Properties;
}

export interface ISignatureInfo extends SignatureInfo.$Properties {
}

export class SignatureInfo {
    constructor(properties?: SignatureInfo.$Properties);
    $unknowns?: Uint8Array[];
    verificationKeyVersion: string;
    verificationKeyId: string;
    signatureAlgorithm: string;
    static create(properties: SignatureInfo.$Shape): SignatureInfo & SignatureInfo.$Shape;
    static create(properties?: SignatureInfo.$Properties): SignatureInfo;
    static encode(message: SignatureInfo.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static encodeDelimited(message: SignatureInfo.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): SignatureInfo & SignatureInfo.$Shape;
    static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): SignatureInfo & SignatureInfo.$Shape;
    static verify(message: { [k: string]: any }): (string|null);
    static fromObject(object: { [k: string]: any }): SignatureInfo;
    static toObject(message: SignatureInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
    toJSON(): { [k: string]: any };
    static getTypeUrl(prefix?: string): string;
}

export namespace SignatureInfo {
    interface $Properties {
        verificationKeyVersion?: (string|null);
        verificationKeyId?: (string|null);
        signatureAlgorithm?: (string|null);
        $unknowns?: Uint8Array[];
    }
    type $Shape = SignatureInfo.$Properties;
}

export interface ITemporaryExposureKey extends TemporaryExposureKey.$Properties {
}

export class TemporaryExposureKey {
    constructor(properties?: TemporaryExposureKey.$Properties);
    $unknowns?: Uint8Array[];
    keyData: Uint8Array;
    transmissionRiskLevel: number;
    rollingStartIntervalNumber: number;
    rollingPeriod: number;
    reportType: TemporaryExposureKey.ReportType;
    daysSinceOnsetOfSymptoms: number;
    static create(properties: TemporaryExposureKey.$Shape): TemporaryExposureKey & TemporaryExposureKey.$Shape;
    static create(properties?: TemporaryExposureKey.$Properties): TemporaryExposureKey;
    static encode(message: TemporaryExposureKey.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static encodeDelimited(message: TemporaryExposureKey.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TemporaryExposureKey & TemporaryExposureKey.$Shape;
    static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TemporaryExposureKey & TemporaryExposureKey.$Shape;
    static verify(message: { [k: string]: any }): (string|null);
    static fromObject(object: { [k: string]: any }): TemporaryExposureKey;
    static toObject(message: TemporaryExposureKey, options?: $protobuf.IConversionOptions): { [k: string]: any };
    toJSON(): { [k: string]: any };
    static getTypeUrl(prefix?: string): string;
}

export namespace TemporaryExposureKey {
    interface $Properties {
        keyData?: (Uint8Array|null);
        transmissionRiskLevel?: (number|null);
        rollingStartIntervalNumber?: (number|null);
        rollingPeriod?: (number|null);
        reportType?: (TemporaryExposureKey.ReportType|null);
        daysSinceOnsetOfSymptoms?: (number|null);
        $unknowns?: Uint8Array[];
    }
    type $Shape = TemporaryExposureKey.$Properties;

    enum ReportType {
        UNKNOWN = 0,
        CONFIRMED_TEST = 1,
        CONFIRMED_CLINICAL_DIAGNOSIS = 2,
        SELF_REPORT = 3,
        RECURSIVE = 4,
        REVOKED = 5
    }
}

export interface ITEKSignatureList extends TEKSignatureList.$Properties {
}

export class TEKSignatureList {
    constructor(properties?: TEKSignatureList.$Properties);
    $unknowns?: Uint8Array[];
    signatures: TEKSignature.$Properties[];
    static create(properties: TEKSignatureList.$Shape): TEKSignatureList & TEKSignatureList.$Shape;
    static create(properties?: TEKSignatureList.$Properties): TEKSignatureList;
    static encode(message: TEKSignatureList.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static encodeDelimited(message: TEKSignatureList.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TEKSignatureList & TEKSignatureList.$Shape;
    static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TEKSignatureList & TEKSignatureList.$Shape;
    static verify(message: { [k: string]: any }): (string|null);
    static fromObject(object: { [k: string]: any }): TEKSignatureList;
    static toObject(message: TEKSignatureList, options?: $protobuf.IConversionOptions): { [k: string]: any };
    toJSON(): { [k: string]: any };
    static getTypeUrl(prefix?: string): string;
}

export namespace TEKSignatureList {
    interface $Properties {
        signatures?: (TEKSignature.$Properties[]|null);
        $unknowns?: Uint8Array[];
    }
    type $Shape = TEKSignatureList.$Properties;
}

export interface ITEKSignature extends TEKSignature.$Properties {
}

export class TEKSignature {
    constructor(properties?: TEKSignature.$Properties);
    $unknowns?: Uint8Array[];
    signatureInfo?: (SignatureInfo.$Properties|null);
    batchNum: number;
    batchSize: number;
    signature: Uint8Array;
    static create(properties: TEKSignature.$Shape): TEKSignature & TEKSignature.$Shape;
    static create(properties?: TEKSignature.$Properties): TEKSignature;
    static encode(message: TEKSignature.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static encodeDelimited(message: TEKSignature.$Properties, writer?: $protobuf.Writer): $protobuf.Writer;
    static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TEKSignature & TEKSignature.$Shape;
    static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): TEKSignature & TEKSignature.$Shape;
    static verify(message: { [k: string]: any }): (string|null);
    static fromObject(object: { [k: string]: any }): TEKSignature;
    static toObject(message: TEKSignature, options?: $protobuf.IConversionOptions): { [k: string]: any };
    toJSON(): { [k: string]: any };
    static getTypeUrl(prefix?: string): string;
}

export namespace TEKSignature {
    interface $Properties {
        signatureInfo?: (SignatureInfo.$Properties|null);
        batchNum?: (number|null);
        batchSize?: (number|null);
        signature?: (Uint8Array|null);
        $unknowns?: Uint8Array[];
    }
    type $Shape = TEKSignature.$Properties;
}