import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
import { type NormalizedClientOptionsWithAuth } from "../../../../BaseClient.js";
import * as core from "../../../../core/index.js";
import * as Vital from "../../../index.js";
export declare namespace LinkClient {
    type Options = BaseClientOptions;
    interface RequestOptions extends BaseRequestOptions {
    }
}
export declare class LinkClient {
    protected readonly _options: NormalizedClientOptionsWithAuth<LinkClient.Options>;
    constructor(options?: LinkClient.Options);
    /**
     * @param {Vital.LinkListBulkOpsRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.listBulkOps({
     *         nextCursor: "next_cursor",
     *         pageSize: 1,
     *         teamId: "infer_from_context"
     *     })
     */
    listBulkOps(request?: Vital.LinkListBulkOpsRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.BulkOpsResponse>;
    private __listBulkOps;
    /**
     * @param {Vital.BulkImportConnectionsBody} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.bulkImport({
     *         teamId: "infer_from_context",
     *         provider: "oura",
     *         connections: [{
     *                 userId: "user_id",
     *                 accessToken: "access_token",
     *                 refreshToken: "refresh_token",
     *                 providerId: "provider_id",
     *                 expiresAt: 1
     *             }]
     *     })
     */
    bulkImport(request: Vital.BulkImportConnectionsBody, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.BulkImportConnectionsResponse>;
    private __bulkImport;
    /**
     * @param {Vital.BulkTriggerHistoricalPullBody} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.bulkTriggerHistoricalPull({
     *         teamId: "infer_from_context",
     *         userIds: ["user_ids"],
     *         provider: "oura"
     *     })
     */
    bulkTriggerHistoricalPull(request: Vital.BulkTriggerHistoricalPullBody, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<unknown>;
    private __bulkTriggerHistoricalPull;
    /**
     * @param {Vital.BulkExportConnectionsBody} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.bulkExport({
     *         teamId: "infer_from_context",
     *         provider: "oura"
     *     })
     */
    bulkExport(request: Vital.BulkExportConnectionsBody, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.BulkExportConnectionsResponse>;
    private __bulkExport;
    /**
     * @param {Vital.BulkPauseConnectionsBody} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.bulkPause({
     *         teamId: "infer_from_context",
     *         userIds: ["user_ids"],
     *         provider: "oura"
     *     })
     */
    bulkPause(request: Vital.BulkPauseConnectionsBody, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<unknown>;
    private __bulkPause;
    /**
     * Endpoint to generate a user link token, to be used throughout the vital
     * link process. The vital link token is a one time use token, that
     * expires after 10 minutes. If you would like vital-link widget to launch
     * with a specific provider, pass in a provider in the body. If you would
     * like to redirect to a custom url after successful or error connection,
     * pass in your own custom redirect_url parameter.
     *
     * @param {Vital.LinkTokenExchange} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.token({
     *         userId: "user_id"
     *     })
     */
    token(request: Vital.LinkTokenExchange, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.LinkTokenExchangeResponse>;
    private __token;
    /**
     * @param {Vital.LinkTokenValidationRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.isTokenValid({
     *         token: "token"
     *     })
     */
    isTokenValid(request: Vital.LinkTokenValidationRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
    private __isTokenValid;
    /**
     * Generate a token to invite a user of Vital mobile app to your team
     *
     * @param {Vital.LinkCodeCreateRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.codeCreate({
     *         userId: "user_id",
     *         expiresAt: new Date("2024-01-15T09:30:00.000Z")
     *     })
     */
    codeCreate(request: Vital.LinkCodeCreateRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.VitalTokenCreatedResponse>;
    private __codeCreate;
    /**
     * REQUEST_SOURCE: VITAL-LINK
     * Start link token process
     *
     * @param {Vital.BeginLinkTokenRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.startConnect({
     *         linkToken: "link_token",
     *         provider: "oura"
     *     })
     */
    startConnect(request: Vital.BeginLinkTokenRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
    private __startConnect;
    /**
     * REQUEST_SOURCE: VITAL-LINK
     * Check link token state - can be hit continuously used as heartbeat
     *
     * @param {Vital.LinkTokenStateRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.tokenState({
     *         vitalLinkToken: "x-vital-link-token"
     *     })
     */
    tokenState(request?: Vital.LinkTokenStateRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Record<string, unknown>>;
    private __tokenState;
    /**
     * Deprecated. Use `POST /v2/link/provider/email/{provider}` instead.
     *
     * @param {Vital.EmailAuthLink} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.emailAuth({
     *         vitalLinkToken: "x-vital-link-token",
     *         email: "email",
     *         provider: "oura",
     *         authType: "password"
     *     })
     */
    emailAuth(request: Vital.EmailAuthLink, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<unknown>;
    private __emailAuth;
    /**
     * Deprecated. Use `POST /v2/link/provider/password/{provider}` instead.
     *
     * @param {Vital.PasswordAuthLink} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.passwordAuth({
     *         vitalLinkToken: "x-vital-link-token",
     *         username: "username",
     *         password: "password",
     *         provider: "oura",
     *         authType: "password"
     *     })
     */
    passwordAuth(request: Vital.PasswordAuthLink, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<unknown>;
    private __passwordAuth;
    /**
     * This endpoint generates an OAuth link for oauth provider
     *
     * @param {Vital.OAuthProviders} oauth_provider
     * @param {Vital.LinkGenerateOauthLinkRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.generateOauthLink("oura", {
     *         vitalLinkToken: "x-vital-link-token"
     *     })
     */
    generateOauthLink(oauth_provider: Vital.OAuthProviders, request?: Vital.LinkGenerateOauthLinkRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.Source>;
    private __generateOauthLink;
    /**
     * This connects auth providers that are password based.
     *
     * @param {Vital.PasswordProviders} provider
     * @param {Vital.IndividualProviderData} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.connectPasswordProvider("whoop", {
     *         vitalLinkToken: "x-vital-link-token",
     *         username: "username",
     *         password: "password"
     *     })
     */
    connectPasswordProvider(provider: Vital.PasswordProviders, request: Vital.IndividualProviderData, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.ProviderLinkResponse>;
    private __connectPasswordProvider;
    /**
     * This connects auth providers that are password based.
     *
     * @param {Vital.PasswordProviders} provider
     * @param {Vital.CompletePasswordProviderMfaBody} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.completePasswordProviderMfa("whoop", {
     *         vitalLinkToken: "x-vital-link-token",
     *         mfaCode: "mfa_code"
     *     })
     */
    completePasswordProviderMfa(provider: Vital.PasswordProviders, request: Vital.CompletePasswordProviderMfaBody, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.ProviderLinkResponse>;
    private __completePasswordProviderMfa;
    /**
     * This connects auth providers that are email based.
     *
     * @param {Vital.EmailProviders} provider
     * @param {Vital.EmailProviderAuthLink} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.connectEmailAuthProvider("freestyle_libre", {
     *         vitalLinkToken: "x-vital-link-token",
     *         email: "email"
     *     })
     */
    connectEmailAuthProvider(provider: Vital.EmailProviders, request: Vital.EmailProviderAuthLink, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<unknown>;
    private __connectEmailAuthProvider;
    /**
     * GET List of all available providers given the generated link token.
     *
     * @param {Vital.LinkGetAllProvidersRequest} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.getAllProviders({
     *         vitalLinkToken: "x-vital-link-token"
     *     })
     */
    getAllProviders(request?: Vital.LinkGetAllProvidersRequest, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.SourceLink[]>;
    private __getAllProviders;
    /**
     * @param {Vital.ManualProviders} provider
     * @param {Vital.ManualConnectionData} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.connectManualProvider("beurer_ble", {
     *         userId: "user_id"
     *     })
     */
    connectManualProvider(provider: Vital.ManualProviders, request: Vital.ManualConnectionData, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Record<string, boolean>>;
    private __connectManualProvider;
    /**
     * POST Connect the given Vital user to a demo provider.
     *
     * @param {Vital.DemoConnectionCreationPayload} request
     * @param {LinkClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Vital.UnprocessableEntityError}
     *
     * @example
     *     await client.link.connectDemoProvider({
     *         userId: "user_id",
     *         provider: "apple_health_kit"
     *     })
     */
    connectDemoProvider(request: Vital.DemoConnectionCreationPayload, requestOptions?: LinkClient.RequestOptions): core.HttpResponsePromise<Vital.DemoConnectionStatus>;
    private __connectDemoProvider;
}