/// <reference types="react" />
export declare enum State {
    ACTIVE = "ACTIVE",
    REVOKED = "REVOKED",
    FROZEN = "FROZEN"
}
export interface ChainErrorResponse {
    errorCode?: string;
}
export type GatewayToken = {
    readonly issuingGatekeeper: string;
    readonly gatekeeperNetworkAddress: string;
    readonly owner: string;
    readonly state: State;
    readonly identifier: string;
    readonly expiryTime?: number;
};
export declare enum TokenState {
    REQUESTED = "REQUESTED",
    ACTIVE = "ACTIVE",
    REVOKED = "REVOKED",
    FROZEN = "FROZEN",
    REJECTED = "REJECTED"
}
export type GatekeeperRecord = {
    walletAddress: string;
    token?: string;
    state: TokenState;
    expiryTimestamp?: number;
    issueTimestamp?: number;
};
export declare enum GatekeeperAPIStatus {
    REQUESTING = 0,
    NOT_REQUESTED = 404,
    REQUESTED = 202,
    ISSUED = 200,
    ISSUED_EXPIRY_APPROACHING = 205,
    ISSUED_EXPIRED = 426,
    LOCATION_NOT_SUPPORTED = 401,
    REJECTED = 403,
    VPN_NOT_SUPPORTED = 421,
    ISSUED_LOCATION_NOT_SUPPORTED = 412,
    ISSUED_VPN_NOT_SUPPORTED = 451,
    SERVER_FAILURE = 500,
    REQUESTED_RETRIES_EXHAUSTED = 408
}
export declare enum GatewayStatus {
    UNKNOWN = 0,
    CHECKING = 1,
    NOT_REQUESTED = 2,
    COLLECTING_USER_INFORMATION = 3,
    PROOF_OF_WALLET_OWNERSHIP = 4,
    IN_REVIEW = 5,
    REJECTED = 6,
    REVOKED = 7,
    FROZEN = 8,
    ACTIVE = 9,
    ERROR = 10,
    LOCATION_NOT_SUPPORTED = 11,
    VPN_NOT_SUPPORTED = 12,
    REFRESH_TOKEN_REQUIRED = 13,
    VALIDATING_USER_INFORMATION = 14,
    USER_INFORMATION_VALIDATED = 15,
    USER_INFORMATION_REJECTED = 16
}
export declare enum ExtendedGatewayStatus {
    AWAITING_OWNER_TRANSACTION = 100,
    CHAIN_TIMEOUT_ERROR = 101,
    CONFIRM_OWNER_TRANSACTION = 102,
    CHAIN_TRANSACTION_ERROR = 103,
    TOKEN_IN_PARTNER_REVIEW = 104,
    TOKEN_REFRESH_IN_REVIEW = 105
}
export type InternalGatewayStatus = GatewayStatus | ExtendedGatewayStatus;
export interface WalletAdapter {
    publicKey: string;
}
/**
 * The properties that the component exposes to the user through useGateway
 */
export type GatewayProps = {
    requestGatewayToken: () => Promise<void>;
    gatewayStatus: GatewayStatus;
    gatewayToken?: GatewayToken;
    gatewayTokenTransaction?: string;
    civicPassSrcUrl?: string;
    pendingRequests?: PendingPayload;
};
/**
 * The properties object passed by the dApp when defining the component
 */
export type GatewayProviderProps = {
    wallet: WalletAdapter | undefined;
    gatekeeperNetwork: string | undefined;
    chainImplementation: ChainLegacy | undefined;
    payer?: string;
    gatekeeperSendsTransaction: boolean;
    stage?: string;
    wrapper?: React.FC;
    logo?: string;
    redirectUrl?: string;
    options?: Options;
    gatewayTokenTransaction?: string;
    children?: React.ReactNode;
    expiryMarginSeconds?: number;
    partnerAppId?: string;
    forceRequireRefresh?: boolean;
    hideWalletPrompts?: boolean;
};
export type CreateTokenRequest = {
    wallet: WalletAdapter;
    payload?: unknown;
    proof?: string;
    payer?: string;
};
export declare enum TokenIssuanceState {
    NOT_REQUESTED = 0,
    IN_PROGRESS = 1,
    IN_PARTNER_REVIEW = 2,
    PENDING_ONCHAIN_CONFIRMATION = 3,
    COMPLETED = 4,
    FAILED = 5
}
export declare enum CivicPassIssuanceStatus {
    NOT_REQUESTED = 0,
    REQUESTED = 1,
    VERIFIED = 2,
    FAILED = 3
}
export declare enum RefreshTokenState {
    NOT_REQUIRED = 0,
    CHECK_TOKEN_EXPIRATION = 1,
    WAIT_FOR_ON_CHAIN = 2,
    IN_PROGRESS = 3,
    REQUIRES_POWO = 4,
    COMPLETED = 5,
    CANCELLED = 6,
    FAILED = 7
}
export declare enum LogLevel {
    DEBUG = "debug",
    INFO = "info",
    WARN = "warn",
    ERROR = "error"
}
export type Options = {
    autoShowModal: boolean;
    logLevel?: LogLevel;
};
export type PendingPayload = {
    presentationRequestId: string;
};
export declare enum FetchStatus {
    FETCHING = "fetching",
    COMPLETE = "complete",
    ERROR = "error"
}
export type RootState = {
    options: Options;
    dataCollectionStatus?: ValidationStatus;
    fetchOnChainStatus: FetchStatus | undefined;
    gatewayStatus: InternalGatewayStatus;
    gatekeeperRecordState?: GatekeeperAPIStatus;
    tokenRequested: boolean;
    iframeMinimized: boolean;
    firstTokenCheck: boolean;
    renderIframe: boolean;
    powoFinished: boolean;
    gatewayToken?: GatewayToken;
    powoRequested?: string;
    walletPowoInProgress: boolean;
    refreshTimeoutId?: number;
    walletToRefresh?: WalletAdapter;
    refreshInProgress: boolean;
    tokenIssuanceState: TokenIssuanceState;
    refreshTokenState: RefreshTokenState | undefined;
    iframeSrcUrl?: string;
    stage: string;
    redirectUrl: string;
    walletAddress?: string;
    civicPass: CivicPassState;
    gatekeeperNetworkAddress?: string;
    chainType: ChainType | undefined;
    chainNetwork: string | undefined;
    payer: string | undefined;
    gatekeeperSendsTransaction: boolean;
    ownerTransactionConfirmed: boolean;
    gatewayTokenTransaction?: string;
    inputExpiryMarginSeconds: number;
    tokenCreatedOrChangedListenerId?: number;
    tokenExpectedTimerId?: number;
    partnerAppId?: string;
    pending?: PendingPayload;
    userInitiatedFlow: boolean;
    instanceId: string;
    signedTx?: string;
    flowId?: string;
    did?: string;
    hideWalletPrompts?: boolean;
};
export type CivicPassActionPayload = {
    payload?: unknown;
    errorCode?: string;
};
export type CivicPassState = {
    status: CivicPassIssuanceStatus;
    requestPayload?: unknown;
    responsePayload?: {
        [CivicPassMessageAction: string]: CivicPassActionPayload;
    };
};
export type ChainHttpConfig = {
    baseUrl: string;
    queryParams: Record<string, string>;
    headers: Record<string, string>;
};
export declare enum ChainType {
    SOLANA = "solana",
    ETHEREUM = "ethereum",
    CASPER = "casper"
}
export interface ChainImplementationProps {
    network?: string;
    owner?: string;
    gatekeeperNetwork?: string;
    stage?: string;
}
export declare enum SignatureMethod {
    TRANSACTION = 0,
    MESSAGE = 1
}
export type ProveWalletOwnershipResponse = {
    proof: string;
    signatureMethod: SignatureMethod;
};
export interface ChainLegacy {
    addOnGatewayTokenChangeListener: (gatewayToken: GatewayToken, tokenDidChange: (GatewayToken: GatewayToken) => void) => Promise<number>;
    addOnGatewayTokenCreatedOrChangedListener?: (tokenChange: (GatewayToken: GatewayToken) => void) => number;
    removeOnGatewayTokenChangeListener: (listenerId: number) => void;
    findGatewayToken: () => Promise<GatewayToken | undefined>;
    proveWalletOwnership: (message?: string) => Promise<ProveWalletOwnershipResponse>;
    signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
    handleUserSignedTransaction: (partiallySignedTx: string) => Promise<string>;
    did: string;
    httpConfig: ChainHttpConfig;
    chainType: ChainType;
    chainNetwork: string;
    dAppHandlesTransactions: boolean;
    initProps: ChainImplementationProps;
    onDestroy: () => void;
}
export declare enum CivicPassMessageEventResult {
    SUCCESS = "success",
    FAILURE = "failure",
    CANCELLED = "cancelled",
    IN_PROGRESS = "inProgress",
    ERROR = "error"
}
export declare enum CivicPassMessageAction {
    ISSUANCE = "issuance",
    CONFIRM_TRANSACTION = "confirmTransaction",
    TOKEN_FROZEN = "tokenFrozen",
    TOKEN_ACTIVE = "tokenActive",
    TOKEN_REVOKED = "tokenRevoked",
    TOKEN_REJECTED = "tokenRejected",
    TOKEN_IN_REVIEW = "tokenInReview",
    TOKEN_REFRESH_IN_REVIEW = "tokenRefreshInReview",
    TOKEN_IN_PARTNER_REVIEW = "tokenInPartnerReview",
    FAILED_IP_CHECK = "failedIpCheck",
    FAILED_VPN_CHECK = "failedVpnCheck",
    REFRESH = "refresh",
    PROOF_OF_WALLET_OWNERSHIP = "proofOfWalletOwnership",
    STATUS = "status",
    ERROR = "error",
    CHAIN_ERROR = "chainError",
    SIGN_TRANSACTION = "signTransaction",
    AWAITING_TRANSACTION_CONFIRMATION = "awaitingTransactionConfirmation"
}
export interface CivicPassMessageResponse {
    event: CivicPassMessageEventResult;
    action: CivicPassMessageAction;
    payload?: unknown;
    instanceId?: string;
}
export type CivicPassMessageResponsePayload = {
    status: ValidationStatus;
};
export interface CivicPassMessageRequest {
    action: CivicPassMessageAction;
    networkAddress: string;
    payload?: string;
}
export interface CivicPassMessageEventResponse extends MessageEvent {
    data: CivicPassMessageResponse;
}
export declare enum ValidationStatus {
    COLLECTING = "COLLECTING",
    PROCESSING = "PROCESSING",
    IN_REVIEW = "IN_REVIEW",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    NOT_FOUND = "NOT_FOUND"
}
export declare class ChainTransactionError extends Error {
    constructor(message: string);
}
export type ErrorWithCode = Error & {
    code?: number;
    message: string;
};
export declare enum FlowType {
    ISSUANCE = "issuance",
    REFRESH = "refresh",
    STATUS = "status"
}