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;
    }>;
}

declare const SISMO_CONNECT_VERSION = "sismo-connect-v1.1";
type SismoConnectRequest = {
    namespace?: string;
    auths?: AuthRequest[];
    claims?: ClaimRequest[];
    signature?: SignatureRequest;
    callbackPath?: string;
    version: string;
};
type SignatureRequest = {
    message: string;
    isSelectableByUser?: boolean;
    extraData?: any;
};
declare enum Vault {
    Main = "main",
    Dev = "dev",
    Demo = "demo"
}
type SismoConnectConfig = {
    appId: string;
    vault?: VaultConfig;
    displayRawResponse?: boolean;
    sismoApiUrl?: string;
    vaultAppBaseUrl?: string;
};
type VaultConfig = {
    impersonate: string[];
};
declare enum ProvingScheme {
    HYDRA_S2 = "hydra-s2.1",
    HYDRA_S3 = "hydra-s3.1"
}
declare enum ClaimType {
    GTE = 0,
    GT = 1,
    EQ = 2,
    LT = 3,
    LTE = 4
}
declare enum AuthType {
    VAULT = 0,
    GITHUB = 1,
    TWITTER = 2,
    EVM_ACCOUNT = 3,
    TELEGRAM = 4
}
type SismoConnectResponse = Pick<SismoConnectRequest, "namespace" | "version"> & {
    appId: string;
    signedMessage?: string;
    proofs: SismoConnectProof[];
};
type SismoConnectProof = {
    auths?: Auth[];
    claims?: Claim[];
    provingScheme: string;
    proofData: string;
    extraData: any;
};
type AuthRequest = {
    authType: AuthType;
    isAnon?: boolean;
    userId?: string;
    isOptional?: boolean;
    isSelectableByUser?: boolean;
    extraData?: any;
};
type Auth = Omit<AuthRequest, "isOptional">;
type ClaimRequest = {
    claimType?: ClaimType;
    groupId?: string;
    groupTimestamp?: number | "latest";
    value?: number;
    isOptional?: boolean;
    isSelectableByUser?: boolean;
    extraData?: any;
};
type Claim = Omit<ClaimRequest, "isOptional">;
type VerifiedClaim = Claim & {
    proofId: string;
    proofData: string;
};
type VerifiedAuth = Auth & {
    proofData: string;
};
declare class SismoConnectVerifiedResult {
    auths: VerifiedAuth[];
    claims: VerifiedClaim[];
    signedMessage: string | undefined;
    response: SismoConnectResponse;
    constructor({ response, claims, auths, }: {
        response: SismoConnectResponse;
        claims: VerifiedClaim[];
        auths: VerifiedAuth[];
    });
    getUserId(authType: AuthType): string | undefined;
    getUserIds(authType: AuthType): string[];
    getSignedMessage(): string | undefined;
}
declare const resolveSismoIdentifier: (sismoIdentifier: string, authType: AuthType) => string;
declare const toSismoIdentifier: (identifier: string, authType: AuthType) => string;
declare class RequestBuilder {
    static buildAuths(auths: AuthRequest[] | AuthRequest): AuthRequest[];
    static buildClaims(claims: ClaimRequest[] | ClaimRequest): ClaimRequest[];
    static buildSignature(signature: SignatureRequest): SignatureRequest;
}

type RequestParams = {
    claims?: ClaimRequest[];
    claim?: ClaimRequest;
    auths?: AuthRequest[];
    auth?: AuthRequest;
    signature?: SignatureRequest;
    namespace?: string;
    callbackPath?: string;
    callbackUrl?: string;
};

declare const SismoConnect: ({ config }: {
    config: SismoConnectConfig;
}) => SismoConnectClient;
declare class SismoConnectClient {
    private _sdk;
    private _sismoConnectConfig;
    constructor({ config }: {
        config: SismoConnectConfig;
    });
    request: ({ claims, claim, auths, auth, signature, namespace, callbackPath, callbackUrl, }: RequestParams) => void;
    getRequestLink: ({ claims, claim, auths, auth, signature, namespace, callbackPath, callbackUrl, }: RequestParams) => string;
    getResponse: () => SismoConnectResponse | null;
    getGroup({ id, name, timestamp }: GroupParams): Promise<GetGroupQueryOutput & {
        data: FetchedData;
    }>;
    getResponseBytes: () => string | null;
}

declare const MAIN_VAULT_APP_BASE_URL = "https://vault-beta.sismo.io";
declare const IMPERSONATION_VAULT_APP_BASE_URL = "https://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>;

declare const sismoConnectErrorsABI: {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
}[];

export { ApiFetcher, Auth, AuthRequest, AuthType, Claim, ClaimRequest, ClaimType, FetchedData, GetGroupQueryOutput, GroupParams, IMPERSONATION_VAULT_APP_BASE_URL, MAIN_VAULT_APP_BASE_URL, ProvingScheme, QueryOptions, RequestBuilder, RequestParams, SISMO_CONNECT_VERSION, Sdk, SignatureRequest, SismoConnect, SismoConnectClient, SismoConnectConfig, SismoConnectProof, SismoConnectRequest, SismoConnectResponse, SismoConnectVerifiedResult, Vault, VaultConfig, VerifiedAuth, VerifiedClaim, getGroupFromIdQuery, getGroupFromNameQuery, resolveSismoIdentifier, sismoApiUrls, sismoConnectErrorsABI, toSismoIdentifier };