import { Meta } from '../../../types';
import { AVCalculateResultContent } from '../..';
declare const meta: Meta<typeof AVCalculateResultContent>;
export default meta;
export declare const Default: {
    render: (args: Meta) => {
        components: {
            AVCalculateResultContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                status: "initial" | "mixing" | "decrypting" | "aggregating" | "finished";
                locale: "ar" | "ca" | "cy" | "da" | "de" | "en" | "es" | "fi" | "fr" | "is" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ro" | "ru" | "sv" | "zh";
                progress: number;
                role: "mixer" | "decrypter" | "all" | "observer";
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
        };
        setup(): {
            args: Meta;
        };
        template: string;
    };
    args: {
        id: string;
        progress: number;
        status: string;
        role: string;
        mixes: number[];
        decryptions: number[];
        elapsed: string;
    };
};
export declare const Mixer: {
    render: (args: Meta) => {
        components: {
            AVCalculateResultContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                status: "initial" | "mixing" | "decrypting" | "aggregating" | "finished";
                locale: "ar" | "ca" | "cy" | "da" | "de" | "en" | "es" | "fi" | "fr" | "is" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ro" | "ru" | "sv" | "zh";
                progress: number;
                role: "mixer" | "decrypter" | "all" | "observer";
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
        };
        setup(): {
            args: Meta;
        };
        template: string;
    };
    args: {
        id: string;
        progress: number;
        status: string;
        role: string;
        mixes: number[];
        decryptions: number[];
        elapsed: string;
    };
};
export declare const Decrypter: {
    render: (args: Meta) => {
        components: {
            AVCalculateResultContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                status: "initial" | "mixing" | "decrypting" | "aggregating" | "finished";
                locale: "ar" | "ca" | "cy" | "da" | "de" | "en" | "es" | "fi" | "fr" | "is" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ro" | "ru" | "sv" | "zh";
                progress: number;
                role: "mixer" | "decrypter" | "all" | "observer";
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
        };
        setup(): {
            args: Meta;
        };
        template: string;
    };
    args: {
        id: string;
        progress: number;
        status: string;
        role: string;
        mixes: number[];
        decryptions: number[];
        elapsed: string;
    };
};
export declare const Observer: {
    render: (args: Meta) => {
        components: {
            AVCalculateResultContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                status: "initial" | "mixing" | "decrypting" | "aggregating" | "finished";
                locale: "ar" | "ca" | "cy" | "da" | "de" | "en" | "es" | "fi" | "fr" | "is" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ro" | "ru" | "sv" | "zh";
                progress: number;
                role: "mixer" | "decrypter" | "all" | "observer";
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
        };
        setup(): {
            args: Meta;
        };
        template: string;
    };
    args: {
        id: string;
        progress: number;
        status: string;
        role: string;
        mixes: number[];
        decryptions: number[];
        elapsed: string;
    };
};
export declare const Completed: {
    render: (args: Meta) => {
        components: {
            AVCalculateResultContent: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                progress: {
                    type: NumberConstructor;
                    default: number;
                    validate: (v: number) => boolean;
                };
                role: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentRole>;
                    default: string;
                };
                status: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentStatus>;
                    default: string;
                };
                mixes: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                decryptions: {
                    type: ArrayConstructor;
                    required: true;
                    validate: (v: Array<number>) => boolean;
                };
                elapsed: {
                    type: import('vue').PropType<import('../../../types').AVCalculateResultContentElapsed>;
                    required: true;
                };
                locale: {
                    type: import('vue').PropType<import('@assemblyvoting/types').SupportedLocale>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                status: "initial" | "mixing" | "decrypting" | "aggregating" | "finished";
                locale: "ar" | "ca" | "cy" | "da" | "de" | "en" | "es" | "fi" | "fr" | "is" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ro" | "ru" | "sv" | "zh";
                progress: number;
                role: "mixer" | "decrypter" | "all" | "observer";
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
        };
        setup(): {
            args: Meta;
        };
        template: string;
    };
    args: {
        id: string;
        progress: number;
        status: string;
        role: string;
        mixes: number[];
        decryptions: number[];
        elapsed: string;
    };
};
//# sourceMappingURL=AVCalculateResultContent.stories.d.ts.map