import type { RequestInit, RequestInfo } from "./internal/builtin-types.mjs";
import type { PromiseOrValue, MergedRequestInit, FinalizedRequestInit } from "./internal/types.mjs";
export type { Logger, LogLevel } from "./internal/utils/log.mjs";
import * as Opts from "./internal/request-options.mjs";
import * as Errors from "./core/error.mjs";
import * as Pagination from "./core/pagination.mjs";
import { type PylonCursorPageParams, PylonCursorPageResponse, type PylonSearchPageParams, PylonSearchPageResponse } from "./core/pagination.mjs";
import * as Uploads from "./core/uploads.mjs";
import * as API from "./resources/index.mjs";
import { APIPromise } from "./core/api-promise.mjs";
import { Activities } from "./resources/activities.mjs";
import { AttachmentCreateParams, AttachmentCreateResponse, Attachments } from "./resources/attachments.mjs";
import { Contact, ContactCreateParams, ContactResponse, ContactRetrieveParams, ContactSearchParams, ContactUpdateParams, Contacts, ContactsPylonSearchPage } from "./resources/contacts.mjs";
import { CustomFieldCreateParams, CustomFieldRetrieveAllParams, CustomFieldUpdateParams, CustomFields } from "./resources/custom-fields.mjs";
import { Me, MeRetrieveResponse } from "./resources/me.mjs";
import { TagCreateParams, TagUpdateParams, Tags } from "./resources/tags.mjs";
import { Team, TeamCreateParams, TeamListResponse, TeamResponse, TeamUpdateParams, Teams } from "./resources/teams.mjs";
import { TicketFormListResponse, TicketForms } from "./resources/ticket-forms.mjs";
import { UserRoleListResponse, UserRoles } from "./resources/user-roles.mjs";
import { User, UserList, UserSearchParams, UserUpdateParams, UserUpdateResponse, Users, UsersPylonSearchPage } from "./resources/users.mjs";
import { Account, AccountCreateParams, AccountListParams, AccountListResponse, AccountResponse, AccountSearchParams, AccountUpdateParams, Accounts, AccountsPylonCursorPage, AccountsPylonSearchPage, Channel, CustomField, ExternalID, Pagination as AccountsAPIPagination, SearchRequest, UserReference } from "./resources/accounts/accounts.mjs";
import { Issue, IssueCreateParams, IssueDeleteResponse, IssueListParams, IssueResponse, IssueSearchParams, IssueSnoozeParams, IssueUpdateParams, Issues, IssuesPylonCursorPage, IssuesPylonSearchPage } from "./resources/issues/issues.mjs";
import { KnowledgeBaseCreateRouteRedirectParams, KnowledgeBaseCreateRouteRedirectResponse, KnowledgeBaseListResponse, KnowledgeBases } from "./resources/knowledge-bases/knowledge-bases.mjs";
import { type Fetch } from "./internal/builtin-types.mjs";
import { HeadersLike, NullableHeaders } from "./internal/headers.mjs";
import { FinalRequestOptions, RequestOptions } from "./internal/request-options.mjs";
import { type LogLevel, type Logger } from "./internal/utils/log.mjs";
export interface ClientOptions {
    /**
     * Defaults to process.env['PYLON_API_KEY'].
     */
    apiKey?: string | undefined;
    /**
     * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
     *
     * Defaults to process.env['PYLON_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;
    /**
     * Set the log level.
     *
     * Defaults to process.env['PYLON_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 Pylon API.
 */
export declare class Pylon {
    #private;
    apiKey: string;
    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 Pylon API.
     *
     * @param {string | undefined} [opts.apiKey=process.env['PYLON_API_KEY'] ?? undefined]
     * @param {string} [opts.baseURL=process.env['PYLON_BASE_URL'] ?? https://api.usepylon.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.
     */
    constructor({ baseURL, apiKey, ...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): Promise<NullableHeaders | undefined>;
    /**
     * Basic re-implementation of `qs.stringify` for primitive types.
     */
    protected stringifyQuery(query: 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?: 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: 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 buildBody;
    static Pylon: typeof Pylon;
    static DEFAULT_TIMEOUT: number;
    static PylonError: typeof Errors.PylonError;
    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;
    issues: API.Issues;
    contacts: API.Contacts;
    teams: API.Teams;
    knowledgeBases: API.KnowledgeBases;
    ticketForms: API.TicketForms;
    accounts: API.Accounts;
    users: API.Users;
    me: API.Me;
    activities: API.Activities;
    attachments: API.Attachments;
    customFields: API.CustomFields;
    tags: API.Tags;
    userRoles: API.UserRoles;
}
export declare namespace Pylon {
    export type RequestOptions = Opts.RequestOptions;
    export import PylonCursorPage = Pagination.PylonCursorPage;
    export { type PylonCursorPageParams as PylonCursorPageParams, type PylonCursorPageResponse as PylonCursorPageResponse, };
    export import PylonSearchPage = Pagination.PylonSearchPage;
    export { type PylonSearchPageParams as PylonSearchPageParams, type PylonSearchPageResponse as PylonSearchPageResponse, };
    export { Issues as Issues, type Issue as Issue, type IssueResponse as IssueResponse, type IssueDeleteResponse as IssueDeleteResponse, type IssuesPylonCursorPage as IssuesPylonCursorPage, type IssuesPylonSearchPage as IssuesPylonSearchPage, type IssueCreateParams as IssueCreateParams, type IssueUpdateParams as IssueUpdateParams, type IssueListParams as IssueListParams, type IssueSearchParams as IssueSearchParams, type IssueSnoozeParams as IssueSnoozeParams, };
    export { Contacts as Contacts, type Contact as Contact, type ContactResponse as ContactResponse, type ContactsPylonSearchPage as ContactsPylonSearchPage, type ContactCreateParams as ContactCreateParams, type ContactRetrieveParams as ContactRetrieveParams, type ContactUpdateParams as ContactUpdateParams, type ContactSearchParams as ContactSearchParams, };
    export { Teams as Teams, type Team as Team, type TeamResponse as TeamResponse, type TeamListResponse as TeamListResponse, type TeamCreateParams as TeamCreateParams, type TeamUpdateParams as TeamUpdateParams, };
    export { KnowledgeBases as KnowledgeBases, type KnowledgeBaseListResponse as KnowledgeBaseListResponse, type KnowledgeBaseCreateRouteRedirectResponse as KnowledgeBaseCreateRouteRedirectResponse, type KnowledgeBaseCreateRouteRedirectParams as KnowledgeBaseCreateRouteRedirectParams, };
    export { TicketForms as TicketForms, type TicketFormListResponse as TicketFormListResponse };
    export { Accounts as Accounts, type Account as Account, type AccountListResponse as AccountListResponse, type AccountResponse as AccountResponse, type Channel as Channel, type CustomField as CustomField, type ExternalID as ExternalID, type AccountsAPIPagination as Pagination, type SearchRequest as SearchRequest, type UserReference as UserReference, type AccountsPylonCursorPage as AccountsPylonCursorPage, type AccountsPylonSearchPage as AccountsPylonSearchPage, type AccountCreateParams as AccountCreateParams, type AccountUpdateParams as AccountUpdateParams, type AccountListParams as AccountListParams, type AccountSearchParams as AccountSearchParams, };
    export { Users as Users, type User as User, type UserList as UserList, type UserUpdateResponse as UserUpdateResponse, type UsersPylonSearchPage as UsersPylonSearchPage, type UserUpdateParams as UserUpdateParams, type UserSearchParams as UserSearchParams, };
    export { Me as Me, type MeRetrieveResponse as MeRetrieveResponse };
    export { Activities as Activities };
    export { Attachments as Attachments, type AttachmentCreateResponse as AttachmentCreateResponse, type AttachmentCreateParams as AttachmentCreateParams, };
    export { CustomFields as CustomFields, type CustomFieldCreateParams as CustomFieldCreateParams, type CustomFieldUpdateParams as CustomFieldUpdateParams, type CustomFieldRetrieveAllParams as CustomFieldRetrieveAllParams, };
    export { Tags as Tags, type TagCreateParams as TagCreateParams, type TagUpdateParams as TagUpdateParams };
    export { UserRoles as UserRoles, type UserRoleListResponse as UserRoleListResponse };
    export type CustomFieldValue = API.CustomFieldValue;
    export type Filter = API.Filter;
}
//# sourceMappingURL=client.d.mts.map