import * as grpc from '@grpc/grpc-js';
import { Long } from '@grpc/proto-loader';
import { MethodDefinition } from '@grpc/proto-loader';
import * as protoLoader from '@grpc/proto-loader';

export declare interface CardInfo {
    'cardId'?: (string);
    'defId'?: (string);
    'firstName'?: (string);
    'lastName'?: (string);
    'team'?: (string);
    'position'?: (string);
    'rarity'?: (string);
    'program'?: (string);
    'stars'?: (number);
    'image'?: (string);
    'isDefault'?: (boolean);
    'level'?: (number);
    'power'?: (number);
    'strength'?: (number);
    'quickness'?: (number);
    'acceleration'?: (number);
    'presence'?: (number);
    'endurance'?: (number);
    'jump'?: (number);
    'carry'?: (number);
}

export declare interface CardInfo__Output {
    'cardId': (string);
    'defId': (string);
    'firstName': (string);
    'lastName': (string);
    'team': (string);
    'position': (string);
    'rarity': (string);
    'program': (string);
    'stars': (number);
    'image': (string);
    'isDefault': (boolean);
    'level': (number);
    'power': (number);
    'strength': (number);
    'quickness': (number);
    'acceleration': (number);
    'presence': (number);
    'endurance': (number);
    'jump': (number);
    'carry': (number);
}

export declare interface GetAllCardRequest {
}

export declare interface GetAllCardRequest__Output {
}

export declare interface GetAllCardResponse {
    'cards'?: ({
        [key: string]: CardInfo;
    });
    'count'?: (number);
    'programs'?: (string)[];
    'positions'?: (string)[];
    'teams'?: (string)[];
}

export declare interface GetAllCardResponse__Output {
    'cards': ({
        [key: string]: CardInfo__Output;
    });
    'count': (number);
    'programs': (string)[];
    'positions': (string)[];
    'teams': (string)[];
}

export declare interface GetCardByTelegramRequest {
    'telegramId'?: (number | string | Long);
}

export declare interface GetCardByTelegramRequest__Output {
    'telegramId': (string);
}

export declare interface GetCardByTelegramResponse {
    'telegramId'?: (number | string | Long);
    'cards'?: (CardInfo)[];
}

export declare interface GetCardByTelegramResponse__Output {
    'telegramId': (string);
    'cards': (CardInfo__Output)[];
}

export declare interface NflRivalCardClient extends grpc.Client {
    getAllCard(argument: GetAllCardRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<GetAllCardResponse__Output>): grpc.ClientUnaryCall;
    getAllCard(argument: GetAllCardRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<GetAllCardResponse__Output>): grpc.ClientUnaryCall;
    getAllCard(argument: GetAllCardRequest, options: grpc.CallOptions, callback: grpc.requestCallback<GetAllCardResponse__Output>): grpc.ClientUnaryCall;
    getAllCard(argument: GetAllCardRequest, callback: grpc.requestCallback<GetAllCardResponse__Output>): grpc.ClientUnaryCall;
    getCardByTelegramId(argument: GetCardByTelegramRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<GetCardByTelegramResponse__Output>): grpc.ClientUnaryCall;
    getCardByTelegramId(argument: GetCardByTelegramRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<GetCardByTelegramResponse__Output>): grpc.ClientUnaryCall;
    getCardByTelegramId(argument: GetCardByTelegramRequest, options: grpc.CallOptions, callback: grpc.requestCallback<GetCardByTelegramResponse__Output>): grpc.ClientUnaryCall;
    getCardByTelegramId(argument: GetCardByTelegramRequest, callback: grpc.requestCallback<GetCardByTelegramResponse__Output>): grpc.ClientUnaryCall;
}

export declare interface NflRivalCardDefinition extends grpc.ServiceDefinition {
    getAllCard: MethodDefinition<GetAllCardRequest, GetAllCardResponse, GetAllCardRequest__Output, GetAllCardResponse__Output>;
    getCardByTelegramId: MethodDefinition<GetCardByTelegramRequest, GetCardByTelegramResponse, GetCardByTelegramRequest__Output, GetCardByTelegramResponse__Output>;
}

export declare interface NflRivalCardHandlers extends grpc.UntypedServiceImplementation {
    getAllCard: grpc.handleUnaryCall<GetAllCardRequest__Output, GetAllCardResponse>;
    getCardByTelegramId: grpc.handleUnaryCall<GetCardByTelegramRequest__Output, GetCardByTelegramResponse>;
}

declare const Protocols: {
    telegram: {
        auth: {
            TelegramAuth: (new (address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions | undefined) => TelegramAuthClient) & {
                service: TelegramAuthDefinition;
            };
            TelegramAuthRequest: protoLoader.MessageTypeDefinition;
            TelegramAuthResponse: protoLoader.MessageTypeDefinition;
            TelegramParams: protoLoader.MessageTypeDefinition;
            TelegramUser: protoLoader.MessageTypeDefinition;
        };
        bot_check: {
            TelegramBotCheck: (new (address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions | undefined) => TelegramBotCheckClient) & {
                service: TelegramBotCheckDefinition;
            };
            TelegramBotCheckRequest: protoLoader.MessageTypeDefinition;
            TelegramBotCheckResponse: protoLoader.MessageTypeDefinition;
        };
    };
    mythical: {
        nfl_rival_card: {
            CardInfo: protoLoader.MessageTypeDefinition;
            GetAllCardRequest: protoLoader.MessageTypeDefinition;
            GetAllCardResponse: protoLoader.MessageTypeDefinition;
            GetCardByTelegramRequest: protoLoader.MessageTypeDefinition;
            GetCardByTelegramResponse: protoLoader.MessageTypeDefinition;
            NflRivalCard: (new (address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions | undefined) => NflRivalCardClient) & {
                service: NflRivalCardDefinition;
            };
        };
    };
};
export { Protocols }
export default Protocols;

export declare interface TelegramAuthClient extends grpc.Client {
    validate(argument: TelegramAuthRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<TelegramAuthResponse__Output>): grpc.ClientUnaryCall;
    validate(argument: TelegramAuthRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<TelegramAuthResponse__Output>): grpc.ClientUnaryCall;
    validate(argument: TelegramAuthRequest, options: grpc.CallOptions, callback: grpc.requestCallback<TelegramAuthResponse__Output>): grpc.ClientUnaryCall;
    validate(argument: TelegramAuthRequest, callback: grpc.requestCallback<TelegramAuthResponse__Output>): grpc.ClientUnaryCall;
}

export declare interface TelegramAuthDefinition extends grpc.ServiceDefinition {
    validate: MethodDefinition<TelegramAuthRequest, TelegramAuthResponse, TelegramAuthRequest__Output, TelegramAuthResponse__Output>;
}

export declare interface TelegramAuthHandlers extends grpc.UntypedServiceImplementation {
    validate: grpc.handleUnaryCall<TelegramAuthRequest__Output, TelegramAuthResponse>;
}

export declare interface TelegramAuthRequest {
    'botUsername'?: (string);
    'initData'?: (string);
}

export declare interface TelegramAuthRequest__Output {
    'botUsername': (string);
    'initData': (string);
}

export declare interface TelegramAuthResponse {
    'validData'?: (boolean);
    'validTime'?: (boolean);
    'params'?: (TelegramParams | null);
    'error'?: (string);
    '_params'?: "params";
    '_error'?: "error";
}

export declare interface TelegramAuthResponse__Output {
    'validData': (boolean);
    'validTime': (boolean);
    'params'?: (TelegramParams__Output | null);
    'error'?: (string);
    '_params': "params";
    '_error': "error";
}

export declare interface TelegramBotCheckClient extends grpc.Client {
    getUserState(argument: TelegramBotCheckRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<TelegramBotCheckResponse__Output>): grpc.ClientUnaryCall;
    getUserState(argument: TelegramBotCheckRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<TelegramBotCheckResponse__Output>): grpc.ClientUnaryCall;
    getUserState(argument: TelegramBotCheckRequest, options: grpc.CallOptions, callback: grpc.requestCallback<TelegramBotCheckResponse__Output>): grpc.ClientUnaryCall;
    getUserState(argument: TelegramBotCheckRequest, callback: grpc.requestCallback<TelegramBotCheckResponse__Output>): grpc.ClientUnaryCall;
}

export declare interface TelegramBotCheckDefinition extends grpc.ServiceDefinition {
    getUserState: MethodDefinition<TelegramBotCheckRequest, TelegramBotCheckResponse, TelegramBotCheckRequest__Output, TelegramBotCheckResponse__Output>;
}

export declare interface TelegramBotCheckHandlers extends grpc.UntypedServiceImplementation {
    getUserState: grpc.handleUnaryCall<TelegramBotCheckRequest__Output, TelegramBotCheckResponse>;
}

export declare interface TelegramBotCheckRequest {
    'groupId'?: (number | string | Long);
    'telegramId'?: (number | string | Long);
}

export declare interface TelegramBotCheckRequest__Output {
    'groupId': (string);
    'telegramId': (string);
}

export declare interface TelegramBotCheckResponse {
    'success'?: (boolean);
    'telegramId'?: (number | string | Long);
    'groupId'?: (number | string | Long);
    'messageCount'?: (number);
    'timeSinceJoin'?: (string);
}

export declare interface TelegramBotCheckResponse__Output {
    'success': (boolean);
    'telegramId': (string);
    'groupId': (string);
    'messageCount': (number);
    'timeSinceJoin': (string);
}

export declare interface TelegramParams {
    'queryId'?: (string);
    'telegramUser'?: (TelegramUser | null);
    'authDate'?: (number | string | Long);
}

export declare interface TelegramParams__Output {
    'queryId': (string);
    'telegramUser': (TelegramUser__Output | null);
    'authDate': (string);
}

export declare interface TelegramUser {
    'id'?: (number | string | Long);
    'username'?: (string);
    'firstName'?: (string);
    'lastName'?: (string);
    'languageCode'?: (string);
    'allowsWriteToPm'?: (boolean);
    '_username'?: "username";
    '_firstName'?: "firstName";
    '_lastName'?: "lastName";
    '_languageCode'?: "languageCode";
    '_allowsWriteToPm'?: "allowsWriteToPm";
}

export declare interface TelegramUser__Output {
    'id': (string);
    'username'?: (string);
    'firstName'?: (string);
    'lastName'?: (string);
    'languageCode'?: (string);
    'allowsWriteToPm'?: (boolean);
    '_username': "username";
    '_firstName': "firstName";
    '_lastName': "lastName";
    '_languageCode': "languageCode";
    '_allowsWriteToPm': "allowsWriteToPm";
}

export { }