@lokalise/harmony 1.16.0 → 1.17.0

package/dist/types/src/features/auth/core/headers/createHeaderBuilderMiddleware.d.ts

@@ -0,0 +1,32 @@
+import { HeaderBuilder, Headers } from './headerBuilder';
+/**
+ * A helper function that creates a HeaderBuilderMiddleware, it removed the
+ * complexity of creating a new instance of the middleware class and tracking the input types.
+ *
+ * @param middleware - A function that modifies a HeaderBuilder
+ * @returns - A new instance of HeaderBuilderMiddleware to be used with a HeaderBuilder
+ */
+export declare function createHeaderBuilderMiddleware<const H extends Headers>(middleware: (builder: HeaderBuilder) => HeaderBuilder<H> | Promise<HeaderBuilder<H>>): HeaderBuilderMiddleware<H>;
+export type { HeaderBuilderMiddleware };
+/**
+ * A middleware class that allows you to modify a HeaderBuilder in a type-safe way.
+ * It receives a builder and returns a new builder with the modifications applied.
+ *
+ * @example
+ * ```typescript
+ * const authMiddleware = createHeaderBuilderMiddleware(async (builder) => {
+ *   const token = await fetchToken()
+ *   return builder.add('Authorization', `Bearer ${token}`)
+ * })
+ *
+ *  const builder = HeaderBuilder.create()
+ *  .with(authMiddleware)
+ *
+ *  const headers = await builder.resolve() // Type of headers is { 'Authorization': string }
+ *  console.log(headers) // { 'Authorization': 'Bearer <token>' }
+ */
+declare class HeaderBuilderMiddleware<const H extends Headers> {
+    private readonly middleware;
+    constructor(middleware: (builder: HeaderBuilder<Headers>) => HeaderBuilder<H> | Promise<HeaderBuilder<H>>);
+    apply<const BH extends Headers>(base: HeaderBuilder<BH>): HeaderBuilder<BH & H>;
+}

package/dist/types/src/features/auth/core/headers/headerBuilder.d.ts

@@ -0,0 +1,171 @@
+import { HeaderBuilderMiddleware } from './createHeaderBuilderMiddleware';
+export type Headers<K extends string = string, V extends string = string> = Record<K, V>;
+type NoHeaders = {};
+/**
+ * A builder class that helps to build up a set of headers in a type-safe way.
+ * It allows you to add headers, merge them together, and resolve them into a single object.
+ * The builder is immutable, so every operation returns a new instance of the builder.
+ * It offers a middleware function that allows you to modify the builder, asynchronously, in a type-safe way.
+ *
+ * @example
+ * ```typescript
+ * const authMiddleware = createHeaderBuilderMiddleware(async (builder) => {
+ *    const token = await fetchToken()
+ *    return builder.add('Authorization', `Bearer ${token}`)
+ * })
+ *
+ * const builder = HeaderBuilder.create()
+ *    .add('Content-Type', 'application/json')
+ *    .and({ 'X-Custom-Header': 'custom', 'X-Another-Header': 'another' })
+ *    .with(authMiddleware)
+ *
+ * const headers = await builder.resolve()
+ * console.log(headers)
+ * // Prints: {
+ * //    'Content-Type': 'application/json',
+ * //    'X-Custom-Header': 'custom',
+ * //    'X-Another-Header': 'another',
+ * //    'Authorization': 'Bearer <token>'
+ * // }
+ */
+export declare class HeaderBuilder<H extends Headers = NoHeaders> {
+    private readonly factories;
+    /**
+     * Creates a new HeaderBuilder, optionally with an initial set of headers.
+     *
+     * @example
+     * ```typescript
+     * const builder = HeaderBuilder.create()
+     *
+     * const builderWithHeaders = HeaderBuilder.create({ 'Content-Type': 'application/json' })
+     *
+     * console.log(builder) // {}
+     * console.log(builderWithHeaders) // { 'Content-Type': 'application/json' }
+     * ```
+     */
+    static create<const H extends Headers = {}>(): HeaderBuilder<H>;
+    static create<const H extends Headers>(initialHeaders: H): HeaderBuilder<H>;
+    /**
+     * This constructor is private to prevent the creation of a HeaderBuilder, it's an implementation detail
+     * that users of this class should not be aware of. The only way to create a HeaderBuilder is through the
+     * static create method.
+     *
+     * @private
+     */
+    private constructor();
+    /**
+     * Adds a single header to the builder by providing a key and a value.
+     *
+     * @example
+     * ```typescript
+     * const builder = HeaderBuilder.create()
+     *     .add('Content-Type', 'application/json')
+     *     .add('Authorization', 'Bearer token')
+     *
+     *  const headers = await builder.resolve()
+     *  console.log(headers)
+     *  // { 'Content-Type': 'application/json', 'Authorization': 'Bearer token' }
+     * ```
+     *
+     * @param key - The key of the header
+     * @param value - The value of the header
+     */
+    add<const K extends string, const V>(key: K, value: V): HeaderBuilder<H & {
+        [k in K]: V;
+    }>;
+    /**
+     * Adds multiple headers to the builder by providing an object or a promise of an object with the headers.
+     *
+     * @example
+     * ```typescript
+     * const builder = HeaderBuilder.create()
+     *    .and({ 'Content-Type': 'application/json', 'Authorization': 'Bearer token' })
+     *    .and(Promise.resolve({ 'X-Custom-Header': 'custom', 'X-Another-Header': 'another' }))
+     *
+     * const headers = await builder.resolve()
+     * console.log(headers)
+     * // Prints: {
+     * //   'Content-Type': 'application/json',
+     * //   'Authorization': 'Bearer token',
+     * //   'X-Custom-Header': 'custom',
+     * //   'X-Another-Header': 'another'
+     * // }
+     * ```
+     *
+     * @param extension - An object with the headers to add
+     */
+    and<const K extends string, const V extends string, E extends Headers<K, V>>(extension: E | Promise<E>): HeaderBuilder<H & E>;
+    /**
+     * Adds a factory function that returns a promise of headers to the builder.
+     * This is useful when you need to fetch some data asynchronously to build the headers.
+     *
+     * @example
+     * ```typescript
+     * const builder = HeaderBuilder.create()
+     *    .from(async () => {
+     *       const token = await fetchToken()
+     *       return { 'Authorization': `Bearer ${token}` }
+     *    })
+     *
+     * const headers = await builder.resolve()
+     * console.log(headers) // { 'Authorization': 'Bearer <token>' }
+     * ```
+     *
+     * @param factory - A function that returns a promise of headers
+     */
+    from<E extends Headers>(factory: () => E | Promise<E>): HeaderBuilder<H & E>;
+    /**
+     * Takes a middleware function that receives the current builder and returns a new, modified, builder.
+     *
+     * @example
+     * ```typescript
+     * const authMiddleware = createHeaderBuilderMiddleware(async (builder) => {
+     *   const token = await fetchToken()
+     *   return builder.add('Authorization', `Bearer ${token}`)
+     * })
+     *
+     * const builder = HeaderBuilder.create()
+     *   .with(authMiddleware)
+     *
+     * const headers = await builder.resolve() // Type of headers is { 'Authorization': string }
+     * console.log(headers) // { 'Authorization': 'Bearer <token>' }
+     * ```
+     *
+     * @param middleware
+     */
+    with<const T extends Headers>(middleware: HeaderBuilderMiddleware<T>): HeaderBuilder<H & T>;
+    /**
+     * Merges the current builder with another builder.
+     *
+     * @example
+     * ```typescript
+     * const builderA = HeaderBuilder.create()
+     *    .add('Content-Type', 'application/json')
+     *
+     * const builderB = HeaderBuilder.create()
+     *    .add('Authorization', 'Bearer token')
+     *
+     * const mergedBuilder = builderA.merge(builderB)
+     *
+     * const headers = await mergedBuilder.resolve()
+     * console.log(headers)
+     * // { 'Content-Type': 'application/json', 'Authorization': 'Bearer token' }
+     * ```
+     *
+     * @param builder - The builder to merge with
+     */
+    merge<const T extends Headers>(builder: HeaderBuilder<T>): HeaderBuilder<H & T>;
+    /**
+     * Resolves the headers by waiting for all the promises to resolve and merging them together.
+     *
+     * @example
+     * ```typescript
+     * const builder = HeaderBuilder.create()
+     *    .add('Content-Type', 'application/json')
+     *
+     * const headers = await builder.resolve()
+     * console.log(headers) // { 'Content-Type': 'application/json' }
+     */
+    resolve(): Promise<H>;
+}
+export {};

package/dist/types/src/features/auth/core/middleware/jwtAuthHeaderBuilderMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { JwtToken } from '../../../publicApi/types/userTokenTypes';
+export type JwtAuthHeaderBuilderMiddlewareProps = {
+    refreshToken: (current: JwtToken) => Promise<JwtToken | null>;
+    getCurrentToken: () => JwtToken | null;
+    generateNewToken?: () => Promise<JwtToken | null>;
+    onNewTokenIssued?: (token: JwtToken) => void;
+};
+export declare function JwtAuthHeaderBuilderMiddleware(props: JwtAuthHeaderBuilderMiddlewareProps): import('../headers/createHeaderBuilderMiddleware').HeaderBuilderMiddleware<{
+    Authorization: `Bearer ${string}`;
+}>;

package/dist/types/src/features/auth/core/middleware/publicApiHeaderBuilderMiddleware.d.ts

@@ -0,0 +1,3 @@
+export declare const PublicApiHeaderBuilderMiddleware: import('../headers/createHeaderBuilderMiddleware').HeaderBuilderMiddleware<{
+    'x-lokalise-plugin': "true";
+}>;

package/dist/types/src/features/auth/core/types/jwtTokenPayload.d.ts

@@ -18,9 +18,9 @@ export declare const JWT_TOKEN_PAYLOAD_SCHEMA: z.ZodObject<{
     planId: number;
     userTeamRole: "member" | "admin" | "biller" | "owner";
     userEmail: string;
-    teamId: number;
     userId: number;
     userUuid: string;
+    teamId: number;
     userName: string;
     userCurrentTeamId: number;
     planName: string;
@@ -31,9 +31,9 @@ export declare const JWT_TOKEN_PAYLOAD_SCHEMA: z.ZodObject<{
     planId: number;
     userTeamRole: "member" | "admin" | "biller" | "owner";
     userEmail: string;
-    teamId: number;
     userId: number;
     userUuid: string;
+    teamId: number;
     userName: string;
     userCurrentTeamId: number;
     planName: string;

package/dist/types/src/features/auth/core/types/jwtTokenPayload.fixture.d.ts

@@ -4,22 +4,22 @@ export declare const createMockJwtTokenPayload: (overrides?: {
     planId?: number | undefined;
     userTeamRole?: "member" | "admin" | "biller" | "owner" | undefined;
     userEmail?: string | undefined;
-    teamId?: number | undefined;
     userId?: number | undefined;
     userUuid?: string | undefined;
+    teamId?: number | undefined;
     userName?: string | undefined;
     userCurrentTeamId?: number | undefined;
     planName?: string | undefined;
     exp?: number | undefined;
-} | undefined, removeProperties?: ("isProviderAlpha" | "isFullyAuthenticated" | "planId" | "userTeamRole" | "userEmail" | "teamId" | "userId" | "userUuid" | "userName" | "userCurrentTeamId" | "planName" | "exp")[]) => {
+} | undefined, removeProperties?: ("isProviderAlpha" | "isFullyAuthenticated" | "planId" | "userTeamRole" | "userEmail" | "userId" | "userUuid" | "teamId" | "userName" | "userCurrentTeamId" | "planName" | "exp")[]) => {
     isProviderAlpha: boolean;
     isFullyAuthenticated: boolean;
     planId: number;
     userTeamRole: "member" | "admin" | "biller" | "owner";
     userEmail: string;
-    teamId: number;
     userId: number;
     userUuid: string;
+    teamId: number;
     userName: string;
     userCurrentTeamId: number;
     planName: string;

package/dist/types/src/features/auth/core/utils/makeAuthHeader.d.ts

@@ -1,2 +1,2 @@
-import { AuthenticatedRequestHeader } from '../../../publicApi/types/userTokenTypes';
-export declare function makeAuthHeader(token: string): AuthenticatedRequestHeader;
+import { UserTokenRequestHeader } from '../../../publicApi/types/userTokenTypes';
+export declare function makeAuthHeader(token: string): UserTokenRequestHeader;

package/dist/types/src/features/auth/errors/UnauthorizedError.d.ts

@@ -0,0 +1,4 @@
+export declare class UnauthorizedError extends Error {
+    readonly name = "UnauthorizedError";
+    readonly status = 401;
+}

package/dist/types/src/features/auth/frontend/hooks/useAuthenticatedProjectContributor.d.ts

@@ -1,3 +1,5 @@
+import { HeaderBuilder } from '../../core/headers/headerBuilder';
+import { ContributorApiBaseHeader } from '../../../publicApi/types/contributorTypes';
 import { Wretch } from 'wretch';
 /**
  * Uses the payload attached to the JWT to request the contributor information
@@ -5,9 +7,10 @@ import { Wretch } from 'wretch';
  * This required an active JWT token to be present in the cookie.
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - The headers to attach to the request.
  * @param projectId - The ID of the project to retrieve the contributor information.
  */
-export declare function useAuthenticatedProjectContributor<T>(wretchClient: Wretch<T>, projectId: string): import('@tanstack/react-query').UseQueryResult<{
+export declare function useAuthenticatedProjectContributor<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ContributorApiBaseHeader>, projectId: string): import('@tanstack/react-query').UseQueryResult<{
     contributors: {
         email: string;
         user_id: number;

package/dist/types/src/features/auth/frontend/hooks/useAuthenticatedSessionPayload.d.ts

@@ -8,9 +8,9 @@ export declare function useAuthenticatedSessionPayload(): {
     planId: number;
     userTeamRole: "member" | "admin" | "biller" | "owner";
     userEmail: string;
-    teamId: number;
     userId: number;
     userUuid: string;
+    teamId: number;
     userName: string;
     userCurrentTeamId: number;
     planName: string;

package/dist/types/src/features/auth/frontend/hooks/useAuthenticatedUser.d.ts

@@ -1,11 +1,14 @@
+import { HeaderBuilder } from '../../core/headers/headerBuilder';
+import { TeamUserApiBaseHeaders } from '../../../publicApi/types/teamUserTypes';
 import { Wretch } from 'wretch';
 /**
  * Uses the payload attached to the JWT to request the team-user information for the authenticated user.
  * This required an active JWT token to be present in the cookie.
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - Headers to be attached to the request.
  */
-export declare function useAuthenticatedUser<T>(wretchClient: Wretch<T>): import('@tanstack/react-query').UseQueryResult<{
+export declare function useAuthenticatedUser<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<TeamUserApiBaseHeaders>): import('@tanstack/react-query').UseQueryResult<{
     team_id: number;
     team_user: {
         role: "member" | "admin" | "biller" | "owner";

package/dist/types/src/features/auth/frontend/hooks/useGetPromotedClassicSessionJwtQuery.d.ts

@@ -1,12 +1,14 @@
+import { HeaderBuilder } from '../../core/headers/headerBuilder';
 import { Wretch } from 'wretch';
 /**
  * For use in environments that are authenticated with a classic CSRF PHP session (e.g. Expert).
  * This hook will send that token to the public API, upgrade to a JWT session.
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - The headers to send with the request.
  * @param teamId - The team ID to get the JWT for.
  */
-export declare function useGetPromotedClassicSessionJwtQuery<T>(wretchClient: Wretch<T>, teamId: number): import('@tanstack/react-query').UseQueryResult<{
+export declare function useGetPromotedClassicSessionJwtQuery<T>(wretchClient: Wretch<T>, headers: HeaderBuilder, teamId: number): import('@tanstack/react-query').UseQueryResult<{
     accessToken: string;
     refreshToken: string;
-}, undefined>;
+} | null, undefined>;

package/dist/types/src/features/auth/frontend/services/generateTokenFromClassicSession.d.ts

@@ -0,0 +1,5 @@
+import { Wretch } from 'wretch';
+export declare function generateTokenFromClassicSession<T>(authenticationProvider: Wretch<T>, getCsrfToken: () => string | null, getTeamId: () => Promise<string>): () => Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;

package/dist/types/src/features/auth/frontend/services/refreshExpiredToken.d.ts

@@ -0,0 +1,6 @@
+import { JwtToken } from '../../../publicApi/types/userTokenTypes';
+import { Wretch } from 'wretch';
+export declare function refreshExpiredToken<T>(authenticationProvider: Wretch<T>, getTeamId: () => Promise<string>): ({ refreshToken }: JwtToken) => Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;

package/dist/types/src/features/auth/frontend/utils/cookieTokenUtils.d.ts

@@ -1,4 +1,4 @@
 import { JwtToken } from '../../../publicApi/types/userTokenTypes';
-export declare function getJwtTokenFromCookie(): JwtToken | undefined;
-export declare function getCsrfTokenFromCookie(): string | undefined;
+export declare function getJwtTokenFromCookie(): JwtToken | null;
+export declare function getCsrfTokenFromCookie(): string | null;
 export declare function getCookie(cookies: string, name: string): string | undefined;

package/dist/types/src/features/auth/node.d.ts

@@ -1,11 +1,14 @@
-export { jwtAuthMiddleware } from './core/middleware/jwtAuthMiddleware';
-export { publicApiHeadersMiddleware } from './core/middleware/publicApiHeadersMiddleware';
-export { clientSideJwtAuthMiddleware } from './frontend/middleware/clientSideJwtAuthMiddleware';
-export { promoteClassicSessionToJwtMiddleware } from './frontend/middleware/promoteClassicSessionToJwtMiddleware';
+export { JwtAuthHeaderBuilderMiddleware, type JwtAuthHeaderBuilderMiddlewareProps, } from './core/middleware/jwtAuthHeaderBuilderMiddleware';
+export { PublicApiHeaderBuilderMiddleware } from './core/middleware/publicApiHeaderBuilderMiddleware';
 export type { JwtTokenPayload } from './core/types/jwtTokenPayload';
 export { parseJwtTokenPayload } from './core/utils/jwtTokenPayload';
+export { getJwtTokenFromCookie, getCsrfTokenFromCookie } from './frontend/utils/cookieTokenUtils';
+export { HeaderBuilder, type Headers, } from './core/headers/headerBuilder';
 export * from './backend/services/getAuthenticatedSessionDetailFromRequest';
+export * from './frontend/services/generateTokenFromClassicSession';
+export * from './frontend/services/refreshExpiredToken';
 export * from './frontend/hooks/useGetPromotedClassicSessionJwtQuery';
 export * from './frontend/hooks/useAuthenticatedSessionPayload';
 export * from './frontend/hooks/useAuthenticatedUser';
 export * from './frontend/hooks/useAuthenticatedProjectContributor';
+export { createHeaderBuilderMiddleware, type HeaderBuilderMiddleware, } from './core/headers/createHeaderBuilderMiddleware';

package/dist/types/src/features/publicApi/contributors.d.ts

@@ -108,4 +108,22 @@ export declare const retrieveContributor: import('@lokalise/universal-ts-utils/n
 }, {
     projectId: string;
     contributorId: number;
-}>, undefined, undefined, false, false>;
+}>, undefined, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
+    Authorization: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    Authorization: string;
+}, {
+    Authorization: string;
+}>, z.ZodObject<{
+    'X-API-Token': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'X-API-Token': string;
+}, {
+    'X-API-Token': string;
+}>]>, z.ZodObject<{
+    'X-Lokalise-Plugin': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'X-Lokalise-Plugin': string;
+}, {
+    'X-Lokalise-Plugin': string;
+}>>, false, false>;

package/dist/types/src/features/publicApi/hooks/useCreateProjectMutation.d.ts

@@ -1,13 +1,15 @@
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
 import { ApiMutationOverrides } from '../../../utils/types/apiMutationOverrides';
 import { Wretch } from 'wretch';
-import { CreateProjectRequestBody, Project } from '../types/projectTypes';
+import { CreateProjectRequestBody, Project, ProjectApiBaseHeaders } from '../types/projectTypes';
 /**
  * A react-router wrapper about the createProject public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - A header builder instance to resolve the headers for the request.
  * @param overrides - Additional options to pass to the query.
  */
-export declare function useCreateProjectMutation<T>(wretchClient: Wretch<T>, overrides?: ApiMutationOverrides<Project, CreateProjectRequestBody>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useCreateProjectMutation<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ProjectApiBaseHeaders>, overrides?: ApiMutationOverrides<Project, CreateProjectRequestBody>): import('@tanstack/react-query').UseMutationResult<{
     name: string;
     created_at: string;
     created_at_timestamp: number;

package/dist/types/src/features/publicApi/hooks/useGetTeamUsersQuery.d.ts

@@ -1,4 +1,5 @@
-import { TeamUserResponse } from '../types/teamUserTypes';
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
+import { TeamUserApiBaseHeaders, TeamUserResponse } from '../types/teamUserTypes';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch/types';
 /**
@@ -11,9 +12,10 @@ export declare const getTeamUsersQueryKey: {
  * A react-router wrapper about the getTeamUser public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - Instance of the header builder for the public API.
  * @param overrides - Additional options to pass to the query.
  */
-export declare const useGetTeamUsersQuery: <T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<TeamUserResponse, typeof getTeamUsersQueryKey>) => import('@tanstack/react-query').UseQueryResult<{
+export declare const useGetTeamUsersQuery: <T>(wretchClient: Wretch<T>, headers: HeaderBuilder<TeamUserApiBaseHeaders>, overrides: ApiQueryOverrides<TeamUserResponse, typeof getTeamUsersQueryKey>) => import('@tanstack/react-query').UseQueryResult<{
     team_id: number;
     team_user: {
         role: "member" | "admin" | "biller" | "owner";

package/dist/types/src/features/publicApi/hooks/useGetUserTokenQuery.d.ts

@@ -1,20 +1,21 @@
-import { JwtToken } from '../types/userTokenTypes';
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
+import { JwtToken, UserTokenRequestHeader } from '../types/userTokenTypes';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch/types';
 /**
  * Factory for generating keys for the getUserToken public API endpoint
  */
 export declare const getUserTokenKey: {
-    teamKeyCsrf: (teamId: number, csrf: string) => readonly ["getUserToken", "x-csrf-token", string, number];
-    teamKeyJwt: (teamId: number, refreshToken: string) => readonly ["getUserToken", "Authorization", `Bearer ${string}`, number];
+    teamKey: (teamId: number) => readonly ["getUserToken", number];
 };
 /**
  * A react-router wrapper about the getUserToken public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - HeaderBuilder instance to resolve headers for the request.
  * @param overrides - Additional options to pass to the query.
  */
-export declare const useGetUserTokenQuery: <T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<JwtToken, typeof getUserTokenKey>) => import('@tanstack/react-query').UseQueryResult<{
+export declare const useGetUserTokenQuery: <T>(wretchClient: Wretch<T>, headers: HeaderBuilder<UserTokenRequestHeader>, overrides: ApiQueryOverrides<JwtToken | null, typeof getUserTokenKey>) => import('@tanstack/react-query').UseQueryResult<{
     accessToken: string;
     refreshToken: string;
-}, undefined>;
+} | null, undefined>;

package/dist/types/src/features/publicApi/hooks/useListProjectLanguagesQuery.d.ts

@@ -1,10 +1,19 @@
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
 import { ListProjectLanguagesResponse } from '../types/languageTypes';
+import { ProjectApiBaseHeaders } from '../types/projectTypes';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch/types';
 export declare const listProjectLanguagesKey: {
     projectIdKey: (projectId: string) => readonly ["listProjectLanguages", string];
 };
-export declare function useListProjectLanguagesQuery<T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<ListProjectLanguagesResponse, typeof listProjectLanguagesKey>): import('@tanstack/react-query').UseQueryResult<{
+/**
+ * A react-router wrapper about the listProjectLanguages public API endpoint
+ *
+ * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - A header builder instance to resolve the headers for the request.
+ * @param overrides - Additional options to pass to the query.
+ */
+export declare function useListProjectLanguagesQuery<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ProjectApiBaseHeaders>, overrides: ApiQueryOverrides<ListProjectLanguagesResponse, typeof listProjectLanguagesKey>): import('@tanstack/react-query').UseQueryResult<{
     languages: {
         lang_id: number;
         lang_iso: string;

package/dist/types/src/features/publicApi/hooks/useListProjectsQuery.d.ts

@@ -1,4 +1,5 @@
-import { ListProjectsRequestQuery, ListProjectsSuccessResponseBody } from '../types/projectTypes';
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
+import { ListProjectsRequestQuery, ListProjectsSuccessResponseBody, ProjectApiBaseHeaders } from '../types/projectTypes';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch';
 /**
@@ -19,9 +20,10 @@ export declare const listProjectsKey: {
  * A react-router wrapper about the listProjects public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - A header builder instance to resolve the headers.
  * @param overrides - Additional options to pass to the query.
  */
-export declare function useListProjectsQuery<T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<ListProjectsSuccessResponseBody, typeof listProjectsKey>): import('@tanstack/react-query').UseQueryResult<{
+export declare function useListProjectsQuery<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ProjectApiBaseHeaders>, overrides: ApiQueryOverrides<ListProjectsSuccessResponseBody, typeof listProjectsKey>): import('@tanstack/react-query').UseQueryResult<{
     projects: {
         name: string;
         created_at: string;

package/dist/types/src/features/publicApi/hooks/useRetrieveContributorQuery.d.ts

@@ -1,4 +1,5 @@
-import { RetrieveContributorsResponse } from '../types/contributorTypes';
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
+import { ContributorApiBaseHeader, RetrieveContributorsResponse } from '../types/contributorTypes';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch';
 /**
@@ -11,9 +12,10 @@ export declare const retrieveContributorKeys: {
  * A react-router wrapper about the retrieveContributor public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - A header builder instance to resolve headers for the request.
  * @param overrides - Additional options to pass to the query.
  */
-export declare const useRetrieveContributorQuery: <T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<RetrieveContributorsResponse, typeof retrieveContributorKeys>) => import('@tanstack/react-query').UseQueryResult<{
+export declare const useRetrieveContributorQuery: <T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ContributorApiBaseHeader>, overrides: ApiQueryOverrides<RetrieveContributorsResponse, typeof retrieveContributorKeys>) => import('@tanstack/react-query').UseQueryResult<{
     contributors: {
         email: string;
         user_id: number;

package/dist/types/src/features/publicApi/hooks/useRetrieveProjectQuery.d.ts

@@ -1,6 +1,7 @@
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
 import { ApiQueryOverrides } from '../../../utils/types/apiQueryOverrides';
 import { Wretch } from 'wretch';
-import { Project } from '../types/projectTypes';
+import { Project, ProjectApiBaseHeaders } from '../types/projectTypes';
 /**
  * Factory function to create the query key for the retrieveProject query
  */
@@ -11,9 +12,10 @@ export declare const retrieveProjectQueryKey: {
  * A react-router wrapper about the retrieveProject public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - A header builder instance to resolve the headers for the request.
  * @param overrides - Additional options to pass to the query.
  */
-export declare function useRetrieveProjectQuery<T>(wretchClient: Wretch<T>, overrides: ApiQueryOverrides<Project, typeof retrieveProjectQueryKey>): import('@tanstack/react-query').UseQueryResult<{
+export declare function useRetrieveProjectQuery<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ProjectApiBaseHeaders>, overrides: ApiQueryOverrides<Project, typeof retrieveProjectQueryKey>): import('@tanstack/react-query').UseQueryResult<{
     name: string;
     created_at: string;
     created_at_timestamp: number;

package/dist/types/src/features/publicApi/hooks/useUpdateProjectMutation.d.ts

@@ -1,14 +1,16 @@
+import { HeaderBuilder } from '../../auth/core/headers/headerBuilder';
 import { ApiMutationOverrides } from '../../../utils/types/apiMutationOverrides';
 import { Wretch } from 'wretch';
-import { Project, UpdateProjectPathParams, UpdateProjectRequestBody } from '../types/projectTypes';
+import { Project, ProjectApiBaseHeaders, UpdateProjectPathParams, UpdateProjectRequestBody } from '../types/projectTypes';
 /**
  * A react-query wrapper about the updateProject public API endpoint
  *
  * @param wretchClient - Wretch instance configured to a public API instance.
+ * @param headers - Headers to include in the request.
  * @param params - URL parameters
  * @param overrides - Additional options to pass to the query.
  */
-export declare function useUpdateProjectMutation<T>(wretchClient: Wretch<T>, params: UpdateProjectPathParams, overrides?: ApiMutationOverrides<Project, UpdateProjectRequestBody>): import('@tanstack/react-query').UseMutationResult<{
+export declare function useUpdateProjectMutation<T>(wretchClient: Wretch<T>, headers: HeaderBuilder<ProjectApiBaseHeaders>, params: UpdateProjectPathParams, overrides?: ApiMutationOverrides<Project, UpdateProjectRequestBody>): import('@tanstack/react-query').UseMutationResult<{
     name: string;
     created_at: string;
     created_at_timestamp: number;

package/dist/types/src/features/publicApi/languages.d.ts

@@ -48,4 +48,22 @@ export declare const listProjectLanguages: import('@lokalise/universal-ts-utils/
     projectId: string;
 }, {
     projectId: string;
-}>, undefined, undefined, false, false>;
+}>, undefined, import('zod').ZodIntersection<import('zod').ZodUnion<[import('zod').ZodObject<{
+    Authorization: import('zod').ZodString;
+}, "strip", import('zod').ZodTypeAny, {
+    Authorization: string;
+}, {
+    Authorization: string;
+}>, import('zod').ZodObject<{
+    'X-API-Token': import('zod').ZodString;
+}, "strip", import('zod').ZodTypeAny, {
+    'X-API-Token': string;
+}, {
+    'X-API-Token': string;
+}>]>, import('zod').ZodObject<{
+    'X-Lokalise-Plugin': import('zod').ZodString;
+}, "strip", import('zod').ZodTypeAny, {
+    'X-Lokalise-Plugin': string;
+}, {
+    'X-Lokalise-Plugin': string;
+}>>, false, false>;

package/dist/types/src/features/publicApi/node.d.ts

@@ -8,7 +8,7 @@ export type { Project, ProjectQaIssues, ProjectType, ProjectSettings } from './t
 export type { TeamRole } from './types/teamRoleTypes';
 export type { Contributor, ContributorLanguage } from './types/contributorTypes';
 export type { TeamUser } from './types/teamUserTypes';
-export type { AuthenticatedRequestHeader, JwtToken } from './types/userTokenTypes';
+export type { UserTokenRequestHeader, JwtToken } from './types/userTokenTypes';
 export * from './hooks/useCreateProjectMutation';
 export * from './hooks/useGetTeamUsersQuery';
 export * from './hooks/useGetUserTokenQuery';