import type { RequestInit, RequestInfo } from "./internal/builtin-types.js";
import type { PromiseOrValue, MergedRequestInit, FinalizedRequestInit } from "./internal/types.js";
export type { Logger, LogLevel } from "./internal/utils/log.js";
import * as Opts from "./internal/request-options.js";
import * as Errors from "./core/error.js";
import * as Pagination from "./core/pagination.js";
import { type IndividualsPageParams, IndividualsPageResponse, type PageParams, PageResponse, ResponsesPageResponse, SinglePageResponse } from "./core/pagination.js";
import * as Uploads from "./core/uploads.js";
import * as API from "./resources/index.js";
import { APIPromise } from "./core/api-promise.js";
import { AccessTokenCreateParams, AccessTokens, CreateAccessTokenResponse } from "./resources/access-tokens.js";
import { Account, AccountDisconnectEntityParams, DisconnectEntityResponse, DisconnectResponse, Introspection } from "./resources/account.js";
import { Provider, ProviderListResponse, ProviderListResponsesSinglePage, Providers } from "./resources/providers.js";
import { RequestForwarding, RequestForwardingForwardParams, RequestForwardingForwardResponse } from "./resources/request-forwarding.js";
import { AccountUpdateEvent, BaseWebhookEvent, CompanyEvent, DirectoryEvent, EmploymentEvent, IndividualEvent, JobCompletionEvent, PayStatementEvent, PaymentEvent, WebhookEvent, Webhooks } from "./resources/webhooks.js";
import { Connect } from "./resources/connect/connect.js";
import { HRIS, Income, Location, Money } from "./resources/hris/hris.js";
import { Jobs } from "./resources/jobs/jobs.js";
import { Payroll } from "./resources/payroll/payroll.js";
import { Sandbox } from "./resources/sandbox/sandbox.js";
import { type Fetch } from "./internal/builtin-types.js";
import { HeadersLike, NullableHeaders } from "./internal/headers.js";
import { FinalRequestOptions, RequestOptions } from "./internal/request-options.js";
import { type LogLevel, type Logger } from "./internal/utils/log.js";
export interface ClientOptions {
    accessToken?: string | null | undefined;
    /**
     * Defaults to process.env['FINCH_CLIENT_ID'].
     */
    clientID?: string | null | undefined;
    /**
     * Defaults to process.env['FINCH_CLIENT_SECRET'].
     */
    clientSecret?: string | null | undefined;
    /**
     * Defaults to process.env['FINCH_WEBHOOK_SECRET'].
     */
    webhookSecret?: string | null | undefined;
    /**
     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
     *
     * Defaults to process.env['FINCH_BASE_URL'].
     */
    baseURL?: string | null | undefined;
    /**
     * The maximum amount of time (in milliseconds) that the client should wait for a response
     * from the server before timing out a single request.
     *
     * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
     * much longer than this timeout before the promise succeeds or fails.
     *
     * @unit milliseconds
     */
    timeout?: number | undefined;
    /**
     * Additional `RequestInit` options to be passed to `fetch` calls.
     * Properties will be overridden by per-request `fetchOptions`.
     */
    fetchOptions?: MergedRequestInit | undefined;
    /**
     * Specify a custom `fetch` function implementation.
     *
     * If not provided, we expect that `fetch` is defined globally.
     */
    fetch?: Fetch | undefined;
    /**
     * The maximum number of times that the client will retry a request in case of a
     * temporary failure, like a network error or a 5XX error from the server.
     *
     * @default 2
     */
    maxRetries?: number | undefined;
    /**
     * Default headers to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * header to `null` in request options.
     */
    defaultHeaders?: HeadersLike | undefined;
    /**
     * Default query parameters to include with every request to the API.
     *
     * These can be removed in individual requests by explicitly setting the
     * param to `undefined` in request options.
     */
    defaultQuery?: Record<string, string | undefined> | undefined;
    /**
     * By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
     * Only set this option to `true` if you understand the risks and have appropriate mitigations in place.
     */
    dangerouslyAllowBrowser?: boolean | undefined;
    /**
     * Set the log level.
     *
     * Defaults to process.env['FINCH_LOG'] or 'warn' if it isn't set.
     */
    logLevel?: LogLevel | undefined;
    /**
     * Set the logger.
     *
     * Defaults to globalThis.console.
     */
    logger?: Logger | undefined;
}
/**
 * API Client for interfacing with the Finch API.
 */
export declare class Finch {
    #private;
    accessToken: string | null;
    clientID: string | null;
    clientSecret: string | null;
    webhookSecret: string | null;
    baseURL: string;
    maxRetries: number;
    timeout: number;
    logger: Logger;
    logLevel: LogLevel | undefined;
    fetchOptions: MergedRequestInit | undefined;
    private fetch;
    protected idempotencyHeader?: string;
    private _options;
    /**
     * API Client for interfacing with the Finch API.
     *
     * @param {string | null | undefined} [opts.accessToken]
     * @param {string | null | undefined} [opts.clientID=process.env['FINCH_CLIENT_ID'] ?? null]
     * @param {string | null | undefined} [opts.clientSecret=process.env['FINCH_CLIENT_SECRET'] ?? null]
     * @param {string | null | undefined} [opts.webhookSecret=process.env['FINCH_WEBHOOK_SECRET'] ?? null]
     * @param {string} [opts.baseURL=process.env['FINCH_BASE_URL'] ?? https://api.tryfinch.com] - Override the default base URL for the API.
     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
     * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
     */
    constructor({ baseURL, accessToken, clientID, clientSecret, webhookSecret, ...opts }?: ClientOptions);
    /**
     * Create a new client instance re-using the same options given to the current client with optional overriding.
     */
    withOptions(options: Partial<ClientOptions>): this;
    protected defaultQuery(): Record<string, string | undefined> | undefined;
    protected validateHeaders({ values, nulls }: NullableHeaders): void;
    protected authHeaders(opts: FinalRequestOptions, schemes: {
        bearerAuth?: boolean;
        basicAuth?: boolean;
    }): Promise<NullableHeaders | undefined>;
    protected bearerAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected basicAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined>;
    protected stringifyQuery(query: object | Record<string, unknown>): string;
    private getUserAgent;
    protected defaultIdempotencyKey(): string;
    protected makeStatusError(status: number, error: Object, message: string | undefined, headers: Headers): Errors.APIError;
    buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string;
    /**
     * Used as a callback for mutating the given `FinalRequestOptions` object.
     */
    protected prepareOptions(options: FinalRequestOptions): Promise<void>;
    /**
     * Used as a callback for mutating the given `RequestInit` object.
     *
     * This is useful for cases where you want to add certain headers based off of
     * the request properties, e.g. `method` or `url`.
     */
    protected prepareRequest(request: RequestInit, { url, options }: {
        url: string;
        options: FinalRequestOptions;
    }): Promise<void>;
    get<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    post<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    patch<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    put<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    delete<Rsp>(path: string, opts?: PromiseOrValue<RequestOptions>): APIPromise<Rsp>;
    private methodRequest;
    request<Rsp>(options: PromiseOrValue<FinalRequestOptions>, remainingRetries?: number | null): APIPromise<Rsp>;
    private makeRequest;
    getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(path: string, Page: new (...args: any[]) => PageClass, opts?: PromiseOrValue<RequestOptions>): Pagination.PagePromise<PageClass, Item>;
    requestAPIList<Item = unknown, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(Page: new (...args: ConstructorParameters<typeof Pagination.AbstractPage>) => PageClass, options: PromiseOrValue<FinalRequestOptions>): Pagination.PagePromise<PageClass, Item>;
    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
    private shouldRetry;
    private retryRequest;
    private calculateDefaultRetryTimeoutMillis;
    buildRequest(inputOptions: FinalRequestOptions, { retryCount }?: {
        retryCount?: number;
    }): Promise<{
        req: FinalizedRequestInit;
        url: string;
        timeout: number;
    }>;
    private buildHeaders;
    private _makeAbort;
    private buildBody;
    static Finch: typeof Finch;
    static DEFAULT_TIMEOUT: number;
    static FinchError: typeof Errors.FinchError;
    static APIError: typeof Errors.APIError;
    static APIConnectionError: typeof Errors.APIConnectionError;
    static APIConnectionTimeoutError: typeof Errors.APIConnectionTimeoutError;
    static APIUserAbortError: typeof Errors.APIUserAbortError;
    static NotFoundError: typeof Errors.NotFoundError;
    static ConflictError: typeof Errors.ConflictError;
    static RateLimitError: typeof Errors.RateLimitError;
    static BadRequestError: typeof Errors.BadRequestError;
    static AuthenticationError: typeof Errors.AuthenticationError;
    static InternalServerError: typeof Errors.InternalServerError;
    static PermissionDeniedError: typeof Errors.PermissionDeniedError;
    static UnprocessableEntityError: typeof Errors.UnprocessableEntityError;
    static toFile: typeof Uploads.toFile;
    accessTokens: API.AccessTokens;
    hris: API.HRIS;
    providers: API.Providers;
    account: API.Account;
    webhooks: API.Webhooks;
    requestForwarding: API.RequestForwarding;
    jobs: API.Jobs;
    sandbox: API.Sandbox;
    payroll: API.Payroll;
    connect: API.Connect;
    /**
     * Returns the authorization url which can be visited in order to obtain an
     * authorization code from Finch. The authorization code can then be exchanged for
     * an access token for the Finch api by calling get_access_token().
     */
    getAuthURL({ products, redirectUri, sandbox, }: {
        products: string;
        redirectUri: string;
        sandbox: boolean;
    }): string;
    /**
     * Returns a copy of the current Finch client with the given access token for
     * authentication.
     */
    withAccessToken(accessToken: string): Finch;
}
export declare namespace Finch {
    export type RequestOptions = Opts.RequestOptions;
    export import SinglePage = Pagination.SinglePage;
    export { type SinglePageResponse as SinglePageResponse };
    export import ResponsesPage = Pagination.ResponsesPage;
    export { type ResponsesPageResponse as ResponsesPageResponse };
    export import IndividualsPage = Pagination.IndividualsPage;
    export { type IndividualsPageParams as IndividualsPageParams, type IndividualsPageResponse as IndividualsPageResponse, };
    export import Page = Pagination.Page;
    export { type PageParams as PageParams, type PageResponse as PageResponse };
    export { AccessTokens as AccessTokens, type CreateAccessTokenResponse as CreateAccessTokenResponse, type AccessTokenCreateParams as AccessTokenCreateParams, };
    export { HRIS as HRIS, type Income as Income, type Location as Location, type Money as Money };
    export { Providers as Providers, type Provider as Provider, type ProviderListResponse as ProviderListResponse, type ProviderListResponsesSinglePage as ProviderListResponsesSinglePage, };
    export { Account as Account, type DisconnectEntityResponse as DisconnectEntityResponse, type DisconnectResponse as DisconnectResponse, type Introspection as Introspection, type AccountDisconnectEntityParams as AccountDisconnectEntityParams, };
    export { Webhooks as Webhooks, type AccountUpdateEvent as AccountUpdateEvent, type BaseWebhookEvent as BaseWebhookEvent, type CompanyEvent as CompanyEvent, type DirectoryEvent as DirectoryEvent, type EmploymentEvent as EmploymentEvent, type IndividualEvent as IndividualEvent, type JobCompletionEvent as JobCompletionEvent, type PayStatementEvent as PayStatementEvent, type PaymentEvent as PaymentEvent, type WebhookEvent as WebhookEvent, };
    export { RequestForwarding as RequestForwarding, type RequestForwardingForwardResponse as RequestForwardingForwardResponse, type RequestForwardingForwardParams as RequestForwardingForwardParams, };
    export { Jobs as Jobs };
    export { Sandbox as Sandbox };
    export { Payroll as Payroll };
    export { Connect as Connect };
    export type ConnectionStatusType = API.ConnectionStatusType;
    export type OperationSupport = API.OperationSupport;
    export type OperationSupportMatrix = API.OperationSupportMatrix;
    export type Paging = API.Paging;
}
//# sourceMappingURL=client.d.ts.map