import { BigNumberish } from '@ethersproject/bignumber';

declare const getGroupFromIdQuery = "\n  query getGroup($id: ID!) {\n    group(id: $id) {\n      id\n      name\n      description\n      specs\n      generationFrequency\n      snapshots {\n        timestamp\n        dataUrl\n      }\n    }\n  }\n";
declare const getGroupFromNameQuery = "\n  query getGroup($name: String!) {\n    group(name: $name) {\n      id\n      name\n      description\n      specs\n      generationFrequency\n      snapshots {\n        timestamp\n        dataUrl\n      }\n    }\n  }\n";

type GroupParams = {
    id?: string;
    name?: string;
    timestamp?: string;
};
type FetchedData = Record<string, number>;
type GetGroupQueryOutput = {
    id: string;
    name: string;
    description: string;
    specs: string;
    generationFrequency: string;
    snapshots: {
        timestamp: string;
        dataUrl: string;
    }[];
};

declare class Sdk {
    private _apiFetcher;
    constructor(sismoApiUrl?: string);
    getGroup({ id, name, timestamp }: GroupParams): Promise<GetGroupQueryOutput & {
        data: FetchedData;
    }>;
}

type DevConfig = {
    enabled?: boolean;
    displayRawResponse?: boolean;
    devGroups?: DevGroup[];
};
type DevGroup = {
    groupId: string;
    groupTimestamp?: number | "latest";
    data: DevAddresses;
};
type DevAddresses = string[] | Record<string, Number | BigNumberish>;
declare const ZK_CONNECT_VERSION = "zk-connect-v2";
type ZkConnectRequest = {
    appId: string;
    namespace?: string;
    requestContent?: ZkConnectRequestContent;
    devConfig?: DevConfig;
    callbackPath?: string;
    version: string;
};
type ZkConnectRequestContent = {
    dataRequests: DataRequest[];
    operators: LogicalOperator[];
};
type RequestContentArgs = {
    claimRequest?: Claim;
    authRequest?: Auth;
    messageSignatureRequest?: any;
};
declare enum ProvingScheme {
    HYDRA_S2 = "hydra-s2.1"
}
declare class RequestContentLib {
    static build({ claimRequest, authRequest, messageSignatureRequest, }: RequestContentArgs): ZkConnectRequestContent;
}
type LogicalOperator = 'AND' | 'OR';
type DataRequest = {
    authRequest?: Auth;
    claimRequest?: Claim;
    messageSignatureRequest?: any;
};
type Claim = {
    groupId?: string;
    groupTimestamp?: number | 'latest';
    value?: number;
    claimType?: ClaimType;
    extraData?: any;
};
declare enum ClaimType {
    EMPTY = 0,
    GTE = 1,
    GT = 2,
    EQ = 3,
    LT = 4,
    LTE = 5,
    USER_SELECT = 6
}
declare enum AuthType {
    EMPTY = 0,
    ANON = 1,
    GITHUB = 2,
    TWITTER = 3,
    EVM_ACCOUNT = 4
}
type Auth = {
    authType: AuthType;
    anonMode?: boolean;
    userId?: string;
    extraData?: any;
};
type ZkConnectResponse = Pick<ZkConnectRequest, 'appId' | 'namespace' | 'version'> & {
    proofs: ZkConnectProof[];
};
type ZkConnectProof = {
    auth?: Auth;
    claim?: Claim;
    signedMessage?: string | any;
    provingScheme: string;
    proofData: string;
    extraData: any;
};
type ZkConnectVerifiedResult = ZkConnectResponse & {
    signedMessages: string[];
    verifiedClaims: VerifiedClaim[];
    verifiedAuths: VerifiedAuth[];
};
type VerifiedClaim = Claim & {
    proofId: string;
    __proof: string;
};
type VerifiedAuth = Auth & {
    __proof: string;
};

type RequestParams = {
    claimRequest?: Claim;
    authRequest?: Auth;
    messageSignatureRequest?: any;
    namespace?: string;
    callbackPath?: string;
};
type ZkConnectClientConfig = {
    appId: string;
    devMode?: DevConfig;
    vaultAppBaseUrl?: string;
    sismoApiUrl?: string;
};

declare const ZkConnect: (config: ZkConnectClientConfig) => ZkConnectClient;
declare class ZkConnectClient {
    private _appId;
    private _vaultAppBaseUrl;
    private _devConfig;
    private _devModeEnabled;
    private _sdk;
    constructor({ appId, devMode, vaultAppBaseUrl, sismoApiUrl, }: ZkConnectClientConfig);
    request: ({ claimRequest, authRequest, messageSignatureRequest, namespace, callbackPath, }: RequestParams) => void;
    getRequestLink: ({ claimRequest, authRequest, messageSignatureRequest, namespace, callbackPath, }: RequestParams) => string;
    getResponse: () => ZkConnectResponse | null;
    getGroup({ id, name, timestamp }: GroupParams): Promise<GetGroupQueryOutput & {
        data: FetchedData;
    }>;
    getResponseBytes: () => string | null;
}

declare const PROD_VAULT_APP_BASE_URL = "https://vault-beta.sismo.io";
declare const DEV_VAULT_APP_BASE_URL = "https://dev.vault-beta.sismo.io";

type QueryOptions = {
    query: string;
    variables?: any;
};
declare class ApiFetcher {
    private _url;
    constructor(url: string);
    getWithQuery<T>(opts: QueryOptions): Promise<any>;
}

declare const sismoApiUrls: Record<string, string>;

export { ApiFetcher, Auth, AuthType, Claim, ClaimType, DEV_VAULT_APP_BASE_URL, DataRequest, DevAddresses, DevConfig, DevGroup, FetchedData, GetGroupQueryOutput, GroupParams, LogicalOperator, PROD_VAULT_APP_BASE_URL, ProvingScheme, QueryOptions, RequestContentArgs, RequestContentLib, RequestParams, Sdk, VerifiedAuth, VerifiedClaim, ZK_CONNECT_VERSION, ZkConnect, ZkConnectClient, ZkConnectClientConfig, ZkConnectProof, ZkConnectRequest, ZkConnectRequestContent, ZkConnectResponse, ZkConnectVerifiedResult, getGroupFromIdQuery, getGroupFromNameQuery, sismoApiUrls };