@fingerprint/node-sdk 7.0.0-test.0 → 7.0.0-test.1

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /**
- * Fingerprint Server Node.js SDK v7.0.0-test.0 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
+ * Fingerprint Server Node.js SDK v7.0.0-test.1 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
  */
 
@@ -17,7 +17,7 @@ exports.Region = void 0;
     Region["Global"] = "Global";
 })(exports.Region || (exports.Region = {}));
 
-var version = "7.0.0-test.0";
+var version = "7.0.0-test.1";
 
 const apiVersion = 'v4';
 const euRegionUrl = 'https://eu.api.fpjs.io/';
@@ -65,13 +65,13 @@ function getServerApiUrl(region) {
  *
  * @internal
  *
- * @param {GetRequestPathOptions<Path, Method>} options
- * @param {Path} options.path - The path of the API endpoint
+ * @param {GetRequestPathOptions} options
+ * @param {keyof paths} options.path - The path of the API endpoint
  * @param {string[]} [options.pathParams] - Path parameters to be replaced in the path
- * @param {QueryParams<Path, Method>["queryParams"]} [options.queryParams] - Query string
+ * @param {GetRequestPathOptions["queryParams"]} [options.queryParams] - Query string
  *   parameters to be appended to the URL
  * @param {Region} options.region - The region of the API endpoint
- * @param {Method} options.method - The method of the API endpoint
+ * @param {HttpMethod} options.method - The method of the API endpoint
  *
  * @returns {string} The formatted URL with parameters replaced and query string
  *   parameters appended
@@ -233,6 +233,7 @@ class FingerprintServerApiClient {
             pathParams: [eventId],
             method: 'get',
             queryParams: options,
+            expect: 'json',
         });
     }
     /**
@@ -243,8 +244,8 @@ class FingerprintServerApiClient {
      *
      * **Warning** It's not possible to update events older than one month.
      *
-     * @param body - Data to update the event with.
      * @param eventId The unique event [identifier](https://docs.fingerprint.com/reference/js-agent-v4-get-function#event_id).
+     * @param body - Data to update the event with.
      *
      * @return {Promise<void>}
      *
@@ -256,7 +257,7 @@ class FingerprintServerApiClient {
      * }
      *
      * client
-     *   .updateEvent(body, '<eventId>')
+     *   .updateEvent('<eventId>', body)
      *   .then(() => {
      *     // Event was successfully updated
      *   })
@@ -273,7 +274,7 @@ class FingerprintServerApiClient {
      *   })
      * ```
      */
-    async updateEvent(body, eventId) {
+    async updateEvent(eventId, body) {
         if (!body) {
             throw new TypeError('body is not set');
         }
@@ -285,6 +286,7 @@ class FingerprintServerApiClient {
             pathParams: [eventId],
             method: 'patch',
             body: JSON.stringify(body),
+            expect: 'void',
         });
     }
     /**
@@ -321,6 +323,7 @@ class FingerprintServerApiClient {
             path: '/visitors/{visitor_id}',
             pathParams: [visitorId],
             method: 'delete',
+            expect: 'void',
         });
     }
     /**
@@ -386,6 +389,7 @@ class FingerprintServerApiClient {
             path: '/events',
             method: 'get',
             queryParams: filter,
+            expect: 'json',
         });
     }
     async callApi(options) {
@@ -393,53 +397,53 @@ class FingerprintServerApiClient {
             ...options,
             region: this.region,
         });
+        const requestInit = {
+            method: options.method.toUpperCase(),
+            headers: {
+                ...this.defaultHeaders,
+                ...options.headers,
+            },
+        };
+        if (options.body !== undefined) {
+            requestInit.body = options.body;
+        }
         let response;
         try {
-            response = await this.fetch(url, {
-                method: options.method.toUpperCase(),
-                headers: {
-                    ...this.defaultHeaders,
-                    ...options.headers,
-                },
-                body: options.body,
-            });
+            response = await this.fetch(url, requestInit);
         }
         catch (e) {
-            throw new SdkError('Network or fetch error', undefined, e);
+            throw new SdkError('Network or fetch error', undefined, toError(e));
         }
-        const contentType = response.headers.get('content-type') ?? '';
-        const isJson = contentType.includes('application/json');
         if (response.ok) {
+            if (options.expect === 'void') {
+                return;
+            }
             const hasNoBody = response.status === 204 || response.headers.get('content-length') === '0';
             if (hasNoBody) {
-                return undefined;
+                throw new SdkError('Expected JSON response but response body is empty', response);
             }
-            if (!isJson) {
+            const contentType = response.headers.get('content-type') ?? '';
+            if (!contentType.includes('application/json')) {
                 throw new SdkError('Expected JSON response but received non-JSON content type', response);
             }
-            let data;
-            try {
-                data = await response.clone().json();
-            }
-            catch (e) {
-                throw new SdkError('Failed to parse JSON response', response, toError(e));
-            }
-            return data;
+            return this.parseJson(response);
         }
-        let errPayload;
+        const errorPayload = await this.parseJson(response.clone());
+        if (response.status === 429 && isErrorResponse(errorPayload)) {
+            throw new TooManyRequestsError(errorPayload, response);
+        }
+        if (isErrorResponse(errorPayload)) {
+            throw new RequestError(errorPayload.error.message, errorPayload, response.status, errorPayload.error.code, response);
+        }
+        throw RequestError.unknown(response);
+    }
+    async parseJson(response) {
         try {
-            errPayload = await response.clone().json();
+            return (await response.json());
         }
         catch (e) {
             throw new SdkError('Failed to parse JSON response', response, toError(e));
         }
-        if (isErrorResponse(errPayload)) {
-            if (response.status === 429) {
-                throw new TooManyRequestsError(errPayload, response);
-            }
-            throw new RequestError(errPayload.error.message, errPayload, response.status, errPayload.error.code, response);
-        }
-        throw RequestError.unknown(response);
     }
 }
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Fingerprint Server Node.js SDK v7.0.0-test.0 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
+ * Fingerprint Server Node.js SDK v7.0.0-test.1 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
  */
 
@@ -1542,41 +1542,12 @@ type Event = components['schemas']['Event'];
 type GetEventOptions = paths['/events/{event_id}']['get']['parameters']['query'];
 type EventUpdate = components['schemas']['EventUpdate'];
 type EventRuleAction = components['schemas']['EventRuleAction'];
-type ExtractPathParamStrings<Path> = Path extends {
-    parameters: {
-        path: infer P;
-    };
-} ? P extends Record<string, any> ? [P[keyof P]] : [] : [];
-type ExtractQueryParams<Path> = Path extends {
-    parameters: {
-        query?: infer Q;
-    };
-} ? undefined extends Q ? Q | undefined : Q : never;
-type ExtractRequestBody<Path> = Path extends {
-    requestBody: {
-        content: {
-            'application/json': infer B;
-        };
-    };
-} ? B : never;
-type ExtractResponse<Path> = Path extends {
-    responses: {
-        200: {
-            content: {
-                'application/json': infer R;
-            };
-        };
-    };
-} ? R : void;
-type ApiMethodArgs<Path extends keyof operations> = [
-    ...(ExtractRequestBody<operations[Path]> extends never ? [] : [body: ExtractRequestBody<operations[Path]>]),
-    ...ExtractPathParamStrings<operations[Path]>,
-    ...(ExtractQueryParams<operations[Path]> extends never ? [] : [params: ExtractQueryParams<operations[Path]>])
-];
-type ApiMethod<Path extends keyof operations> = (...args: ApiMethodArgs<Path>) => Promise<ExtractResponse<operations[Path]>>;
-type FingerprintApi = {
-    [Operation in keyof operations]: ApiMethod<Operation>;
-};
+interface FingerprintApi {
+    getEvent(eventId: string, options?: GetEventOptions): Promise<Event>;
+    updateEvent(eventId: string, body: EventUpdate): Promise<void>;
+    searchEvents(filter: SearchEventsFilter): Promise<SearchEventsResponse>;
+    deleteVisitorData(visitorId: string): Promise<void>;
+}
 
 declare class FingerprintServerApiClient implements FingerprintApi {
     readonly region: Region;
@@ -1638,8 +1609,8 @@ declare class FingerprintServerApiClient implements FingerprintApi {
      *
      * **Warning** It's not possible to update events older than one month.
      *
-     * @param body - Data to update the event with.
      * @param eventId The unique event [identifier](https://docs.fingerprint.com/reference/js-agent-v4-get-function#event_id).
+     * @param body - Data to update the event with.
      *
      * @return {Promise<void>}
      *
@@ -1651,7 +1622,7 @@ declare class FingerprintServerApiClient implements FingerprintApi {
      * }
      *
      * client
-     *   .updateEvent(body, '<eventId>')
+     *   .updateEvent('<eventId>', body)
      *   .then(() => {
      *     // Event was successfully updated
      *   })
@@ -1668,7 +1639,7 @@ declare class FingerprintServerApiClient implements FingerprintApi {
      *   })
      * ```
      */
-    updateEvent(body: EventUpdate, eventId: string): Promise<void>;
+    updateEvent(eventId: string, body: EventUpdate): Promise<void>;
     /**
      * Delete data by visitor ID
      * Request deleting all data associated with the specified visitor ID. This API is useful for compliance with privacy regulations. All delete requests are queued:
@@ -1756,6 +1727,7 @@ declare class FingerprintServerApiClient implements FingerprintApi {
      * */
     searchEvents(filter: SearchEventsFilter): Promise<SearchEventsResponse>;
     private callApi;
+    private parseJson;
 }
 
 declare enum DecryptionAlgorithm {

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
- * Fingerprint Server Node.js SDK v7.0.0-test.0 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
+ * Fingerprint Server Node.js SDK v7.0.0-test.1 - Copyright (c) FingerprintJS, Inc, 2026 (https://fingerprint.com)
  * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) license.
  */
 
@@ -15,7 +15,7 @@ var Region;
     Region["Global"] = "Global";
 })(Region || (Region = {}));
 
-var version = "7.0.0-test.0";
+var version = "7.0.0-test.1";
 
 const apiVersion = 'v4';
 const euRegionUrl = 'https://eu.api.fpjs.io/';
@@ -63,13 +63,13 @@ function getServerApiUrl(region) {
  *
  * @internal
  *
- * @param {GetRequestPathOptions<Path, Method>} options
- * @param {Path} options.path - The path of the API endpoint
+ * @param {GetRequestPathOptions} options
+ * @param {keyof paths} options.path - The path of the API endpoint
  * @param {string[]} [options.pathParams] - Path parameters to be replaced in the path
- * @param {QueryParams<Path, Method>["queryParams"]} [options.queryParams] - Query string
+ * @param {GetRequestPathOptions["queryParams"]} [options.queryParams] - Query string
  *   parameters to be appended to the URL
  * @param {Region} options.region - The region of the API endpoint
- * @param {Method} options.method - The method of the API endpoint
+ * @param {HttpMethod} options.method - The method of the API endpoint
  *
  * @returns {string} The formatted URL with parameters replaced and query string
  *   parameters appended
@@ -231,6 +231,7 @@ class FingerprintServerApiClient {
             pathParams: [eventId],
             method: 'get',
             queryParams: options,
+            expect: 'json',
         });
     }
     /**
@@ -241,8 +242,8 @@ class FingerprintServerApiClient {
      *
      * **Warning** It's not possible to update events older than one month.
      *
-     * @param body - Data to update the event with.
      * @param eventId The unique event [identifier](https://docs.fingerprint.com/reference/js-agent-v4-get-function#event_id).
+     * @param body - Data to update the event with.
      *
      * @return {Promise<void>}
      *
@@ -254,7 +255,7 @@ class FingerprintServerApiClient {
      * }
      *
      * client
-     *   .updateEvent(body, '<eventId>')
+     *   .updateEvent('<eventId>', body)
      *   .then(() => {
      *     // Event was successfully updated
      *   })
@@ -271,7 +272,7 @@ class FingerprintServerApiClient {
      *   })
      * ```
      */
-    async updateEvent(body, eventId) {
+    async updateEvent(eventId, body) {
         if (!body) {
             throw new TypeError('body is not set');
         }
@@ -283,6 +284,7 @@ class FingerprintServerApiClient {
             pathParams: [eventId],
             method: 'patch',
             body: JSON.stringify(body),
+            expect: 'void',
         });
     }
     /**
@@ -319,6 +321,7 @@ class FingerprintServerApiClient {
             path: '/visitors/{visitor_id}',
             pathParams: [visitorId],
             method: 'delete',
+            expect: 'void',
         });
     }
     /**
@@ -384,6 +387,7 @@ class FingerprintServerApiClient {
             path: '/events',
             method: 'get',
             queryParams: filter,
+            expect: 'json',
         });
     }
     async callApi(options) {
@@ -391,53 +395,53 @@ class FingerprintServerApiClient {
             ...options,
             region: this.region,
         });
+        const requestInit = {
+            method: options.method.toUpperCase(),
+            headers: {
+                ...this.defaultHeaders,
+                ...options.headers,
+            },
+        };
+        if (options.body !== undefined) {
+            requestInit.body = options.body;
+        }
         let response;
         try {
-            response = await this.fetch(url, {
-                method: options.method.toUpperCase(),
-                headers: {
-                    ...this.defaultHeaders,
-                    ...options.headers,
-                },
-                body: options.body,
-            });
+            response = await this.fetch(url, requestInit);
         }
         catch (e) {
-            throw new SdkError('Network or fetch error', undefined, e);
+            throw new SdkError('Network or fetch error', undefined, toError(e));
         }
-        const contentType = response.headers.get('content-type') ?? '';
-        const isJson = contentType.includes('application/json');
         if (response.ok) {
+            if (options.expect === 'void') {
+                return;
+            }
             const hasNoBody = response.status === 204 || response.headers.get('content-length') === '0';
             if (hasNoBody) {
-                return undefined;
+                throw new SdkError('Expected JSON response but response body is empty', response);
             }
-            if (!isJson) {
+            const contentType = response.headers.get('content-type') ?? '';
+            if (!contentType.includes('application/json')) {
                 throw new SdkError('Expected JSON response but received non-JSON content type', response);
             }
-            let data;
-            try {
-                data = await response.clone().json();
-            }
-            catch (e) {
-                throw new SdkError('Failed to parse JSON response', response, toError(e));
-            }
-            return data;
+            return this.parseJson(response);
         }
-        let errPayload;
+        const errorPayload = await this.parseJson(response.clone());
+        if (response.status === 429 && isErrorResponse(errorPayload)) {
+            throw new TooManyRequestsError(errorPayload, response);
+        }
+        if (isErrorResponse(errorPayload)) {
+            throw new RequestError(errorPayload.error.message, errorPayload, response.status, errorPayload.error.code, response);
+        }
+        throw RequestError.unknown(response);
+    }
+    async parseJson(response) {
         try {
-            errPayload = await response.clone().json();
+            return (await response.json());
         }
         catch (e) {
             throw new SdkError('Failed to parse JSON response', response, toError(e));
         }
-        if (isErrorResponse(errPayload)) {
-            if (response.status === 429) {
-                throw new TooManyRequestsError(errPayload, response);
-            }
-            throw new RequestError(errPayload.error.message, errPayload, response.status, errPayload.error.code, response);
-        }
-        throw RequestError.unknown(response);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fingerprint/node-sdk",
-  "version": "7.0.0-test.0",
+  "version": "7.0.0-test.1",
   "description": "Node.js wrapper for Fingerprint Server API",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -17,6 +17,10 @@
     "type": "git",
     "url": "https://github.com/fingerprintjs/node-sdk"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "engines": {
     "node": ">=18.17.0"
   },

package/src/serverApiClient.ts

@@ -1,4 +1,4 @@
-import { AllowedMethod, getRequestPath, GetRequestPathOptions, SuccessJsonOrVoid } from './urlUtils'
+import { getRequestPath, GetRequestPathOptions } from './urlUtils'
 import {
   Event,
   EventUpdate,
@@ -9,11 +9,16 @@ import {
   SearchEventsFilter,
   SearchEventsResponse,
 } from './types'
-import { paths } from './generatedApiTypes'
 import { RequestError, SdkError, TooManyRequestsError } from './errors/apiErrors'
 import { isErrorResponse } from './errors/handleErrorResponse'
 import { toError } from './errors/toError'
 
+type CallApiOptions = GetRequestPathOptions & {
+  headers?: Record<string, string>
+  body?: BodyInit
+  expect: 'json' | 'void'
+}
+
 export class FingerprintServerApiClient implements FingerprintApi {
   public readonly region: Region
 
@@ -97,6 +102,7 @@ export class FingerprintServerApiClient implements FingerprintApi {
       pathParams: [eventId],
       method: 'get',
       queryParams: options,
+      expect: 'json',
     })
   }
 
@@ -108,8 +114,8 @@ export class FingerprintServerApiClient implements FingerprintApi {
    *
    * **Warning** It's not possible to update events older than one month.
    *
-   * @param body - Data to update the event with.
    * @param eventId The unique event [identifier](https://docs.fingerprint.com/reference/js-agent-v4-get-function#event_id).
+   * @param body - Data to update the event with.
    *
    * @return {Promise<void>}
    *
@@ -121,7 +127,7 @@ export class FingerprintServerApiClient implements FingerprintApi {
    * }
    *
    * client
-   *   .updateEvent(body, '<eventId>')
+   *   .updateEvent('<eventId>', body)
    *   .then(() => {
    *     // Event was successfully updated
    *   })
@@ -138,7 +144,7 @@ export class FingerprintServerApiClient implements FingerprintApi {
    *   })
    * ```
    */
-  public async updateEvent(body: EventUpdate, eventId: string): Promise<void> {
+  public async updateEvent(eventId: string, body: EventUpdate): Promise<void> {
     if (!body) {
       throw new TypeError('body is not set')
     }
@@ -152,6 +158,7 @@ export class FingerprintServerApiClient implements FingerprintApi {
       pathParams: [eventId],
       method: 'patch',
       body: JSON.stringify(body),
+      expect: 'void',
     })
   }
 
@@ -190,6 +197,7 @@ export class FingerprintServerApiClient implements FingerprintApi {
       path: '/visitors/{visitor_id}',
       pathParams: [visitorId],
       method: 'delete',
+      expect: 'void',
     })
   }
 
@@ -256,66 +264,78 @@ export class FingerprintServerApiClient implements FingerprintApi {
       path: '/events',
       method: 'get',
       queryParams: filter,
+      expect: 'json',
     })
   }
 
-  private async callApi<Path extends keyof paths, Method extends AllowedMethod<Path>>(
-    options: GetRequestPathOptions<Path, Method> & { headers?: Record<string, string>; body?: BodyInit }
-  ): Promise<SuccessJsonOrVoid<Path, Method>> {
+  private async callApi<T>(options: CallApiOptions & { expect: 'json' }): Promise<T>
+  private async callApi(options: CallApiOptions & { expect: 'void' }): Promise<void>
+  private async callApi<T>(options: CallApiOptions): Promise<T | void> {
     const url = getRequestPath({
       ...options,
       region: this.region,
     })
 
+    const requestInit: RequestInit = {
+      method: options.method.toUpperCase(),
+      headers: {
+        ...this.defaultHeaders,
+        ...options.headers,
+      },
+    }
+
+    if (options.body !== undefined) {
+      requestInit.body = options.body
+    }
+
     let response: Response
     try {
-      response = await this.fetch(url, {
-        method: options.method.toUpperCase(),
-        headers: {
-          ...this.defaultHeaders,
-          ...options.headers,
-        },
-        body: options.body,
-      })
+      response = await this.fetch(url, requestInit)
     } catch (e) {
-      throw new SdkError('Network or fetch error', undefined, e as Error)
+      throw new SdkError('Network or fetch error', undefined, toError(e))
     }
 
-    const contentType = response.headers.get('content-type') ?? ''
-    const isJson = contentType.includes('application/json')
-
     if (response.ok) {
-      const hasNoBody = response.status === 204 || response.headers.get('content-length') === '0'
+      if (options.expect === 'void') {
+        return
+      }
 
+      const hasNoBody = response.status === 204 || response.headers.get('content-length') === '0'
       if (hasNoBody) {
-        return undefined as SuccessJsonOrVoid<Path, Method>
+        throw new SdkError('Expected JSON response but response body is empty', response)
       }
 
-      if (!isJson) {
+      const contentType = response.headers.get('content-type') ?? ''
+      if (!contentType.includes('application/json')) {
         throw new SdkError('Expected JSON response but received non-JSON content type', response)
       }
 
-      let data
-      try {
-        data = await response.clone().json()
-      } catch (e) {
-        throw new SdkError('Failed to parse JSON response', response, toError(e))
-      }
-      return data as SuccessJsonOrVoid<Path, Method>
+      return this.parseJson(response)
+    }
+
+    const errorPayload = await this.parseJson<unknown>(response.clone())
+
+    if (response.status === 429 && isErrorResponse(errorPayload)) {
+      throw new TooManyRequestsError(errorPayload, response)
+    }
+    if (isErrorResponse(errorPayload)) {
+      throw new RequestError(
+        errorPayload.error.message,
+        errorPayload,
+        response.status,
+        errorPayload.error.code,
+        response
+      )
     }
 
-    let errPayload
+    throw RequestError.unknown(response)
+  }
+
+  private async parseJson<T>(response: Response): Promise<T> {
     try {
-      errPayload = await response.clone().json()
+      return (await response.json()) as T
     } catch (e) {
       throw new SdkError('Failed to parse JSON response', response, toError(e))
     }
-    if (isErrorResponse(errPayload)) {
-      if (response.status === 429) {
-        throw new TooManyRequestsError(errPayload, response)
-      }
-      throw new RequestError(errPayload.error.message, errPayload, response.status, errPayload.error.code, response)
-    }
-    throw RequestError.unknown(response)
   }
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-import { components, operations, paths } from './generatedApiTypes'
+import { components, paths } from './generatedApiTypes'
 
 export enum Region {
   EU = 'EU',
@@ -49,42 +49,9 @@ export type EventUpdate = components['schemas']['EventUpdate']
 
 export type EventRuleAction = components['schemas']['EventRuleAction']
 
-// Extract just the `path` parameters as a tuple of strings
-type ExtractPathParamStrings<Path> = Path extends { parameters: { path: infer P } }
-  ? P extends Record<string, any>
-    ? [P[keyof P]] // We extract the path parameter values as a tuple of strings
-    : []
-  : []
-
-// Utility type to extract query parameters from an operation and differentiate required/optional
-export type ExtractQueryParams<Path> = Path extends { parameters: { query?: infer Q } }
-  ? undefined extends Q // Check if Q can be undefined (meaning it's optional)
-    ? Q | undefined // If so, it's optional
-    : Q // Otherwise, it's required
-  : never // If no query parameters, return never
-
-// Utility type to extract request body from an operation (for POST, PUT, etc.)
-type ExtractRequestBody<Path> = Path extends { requestBody: { content: { 'application/json': infer B } } } ? B : never
-
-// Utility type to extract the response type for 200 status code
-type ExtractResponse<Path> = Path extends { responses: { 200: { content: { 'application/json': infer R } } } }
-  ? R
-  : void
-
-// Extracts args to given API method
-type ApiMethodArgs<Path extends keyof operations> = [
-  // If method has body, extract it as first parameter
-  ...(ExtractRequestBody<operations[Path]> extends never ? [] : [body: ExtractRequestBody<operations[Path]>]),
-  // Next are path params, e.g. for path "/events/{event_id}" it will be one string parameter,
-  ...ExtractPathParamStrings<operations[Path]>,
-  // Last parameter will be the query params, if any
-  ...(ExtractQueryParams<operations[Path]> extends never ? [] : [params: ExtractQueryParams<operations[Path]>]),
-]
-
-type ApiMethod<Path extends keyof operations> = (
-  ...args: ApiMethodArgs<Path>
-) => Promise<ExtractResponse<operations[Path]>>
-
-export type FingerprintApi = {
-  [Operation in keyof operations]: ApiMethod<Operation>
+export interface FingerprintApi {
+  getEvent(eventId: string, options?: GetEventOptions): Promise<Event>
+  updateEvent(eventId: string, body: EventUpdate): Promise<void>
+  searchEvents(filter: SearchEventsFilter): Promise<SearchEventsResponse>
+  deleteVisitorData(visitorId: string): Promise<void>
 }

package/src/urlUtils.ts

@@ -1,4 +1,4 @@
-import { ExtractQueryParams, Region } from './types'
+import { Region } from './types'
 import { version } from '../package.json'
 import { paths } from './generatedApiTypes'
 
@@ -10,8 +10,7 @@ const globalRegionUrl = 'https://api.fpjs.io/'
 
 type QueryStringScalar = string | number | boolean | null | undefined
 
-type QueryStringParameters = Record<string, QueryStringScalar | string[]> & {
-  api_key?: string
+type QueryStringParameters = Record<string, QueryStringScalar | QueryStringScalar[]> & {
   ii: string
 }
 
@@ -57,67 +56,15 @@ function getServerApiUrl(region: Region): string {
   }
 }
 
-/**
- * Extracts parameter placeholders into a literal union type.
- * For example `extractPathParams<'/users/{userId}/posts/{postId}'>` resolves to `"userId" | "postId"
- */
-type ExtractPathParams<T extends string> = T extends `${string}{${infer Param}}${infer Rest}`
-  ? Param | ExtractPathParams<Rest>
-  : never
-
-type PathParams<Path extends keyof paths> =
-  ExtractPathParams<Path> extends never
-    ? { pathParams?: never }
-    : {
-        pathParams: ExtractPathParams<Path> extends never ? never : string[]
-      }
-
-type QueryParams<Path extends keyof paths, Method extends keyof paths[Path]> =
-  ExtractQueryParams<paths[Path][Method]> extends never
-    ? { queryParams?: any } // No query params
-    : {
-        queryParams?: ExtractQueryParams<paths[Path][Method]> // Optional query params
-      }
-
-type IsNever<Type> = [Exclude<Type, undefined>] extends [never] ? true : false
-export type NonNeverKeys<Type> = {
-  [Key in keyof Type]-?: IsNever<Type[Key]> extends true ? never : Key
-}[keyof Type]
-export type AllowedMethod<Path extends keyof paths> = Extract<Exclude<NonNeverKeys<paths[Path]>, 'parameters'>, string>
-
-type JsonContentOf<Response> = Response extends { content: { 'application/json': infer T } } ? T : never
-
-type UnionJsonFromResponses<Response> = {
-  [StatusCode in keyof Response]: JsonContentOf<Response[StatusCode]>
-}[keyof Response]
+export type HttpMethod = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace'
 
-type StartingWithSuccessCode<Response> = {
-  [StatusCode in keyof Response]: `${StatusCode & number}` extends `2${number}${number}` ? StatusCode : never
-}[keyof Response]
-
-type SuccessResponses<Response> = Pick<Response, Extract<StartingWithSuccessCode<Response>, keyof Response>>
-
-type OperationOf<Path extends keyof paths, Method extends AllowedMethod<Path>> = paths[Path][Method]
-
-type ResponsesOf<Path extends keyof paths, Method extends AllowedMethod<Path>> =
-  OperationOf<Path, Method> extends { responses: infer Response } ? Response : never
-
-type SuccessJson<Path extends keyof paths, Method extends AllowedMethod<Path>> = UnionJsonFromResponses<
-  SuccessResponses<ResponsesOf<Path, Method>>
->
-
-export type SuccessJsonOrVoid<Path extends keyof paths, Method extends AllowedMethod<Path>> = [
-  SuccessJson<Path, Method>,
-] extends [never]
-  ? void
-  : SuccessJson<Path, Method>
-
-export type GetRequestPathOptions<Path extends keyof paths, Method extends AllowedMethod<Path>> = {
-  path: Path
-  method: Method
+export interface GetRequestPathOptions {
+  path: keyof paths
+  method: HttpMethod
+  pathParams?: string[]
+  queryParams?: Record<string, QueryStringScalar | QueryStringScalar[]>
   region?: Region
-} & PathParams<Path> &
-  QueryParams<Path, Method>
+}
 
 /**
  * Formats a URL for the FingerprintJS server API by replacing placeholders and
@@ -125,18 +72,18 @@ export type GetRequestPathOptions<Path extends keyof paths, Method extends Allow
  *
  * @internal
  *
- * @param {GetRequestPathOptions<Path, Method>} options
- * @param {Path} options.path - The path of the API endpoint
+ * @param {GetRequestPathOptions} options
+ * @param {keyof paths} options.path - The path of the API endpoint
  * @param {string[]} [options.pathParams] - Path parameters to be replaced in the path
- * @param {QueryParams<Path, Method>["queryParams"]} [options.queryParams] - Query string
+ * @param {GetRequestPathOptions["queryParams"]} [options.queryParams] - Query string
  *   parameters to be appended to the URL
  * @param {Region} options.region - The region of the API endpoint
- * @param {Method} options.method - The method of the API endpoint
+ * @param {HttpMethod} options.method - The method of the API endpoint
  *
  * @returns {string} The formatted URL with parameters replaced and query string
  *   parameters appended
  */
-export function getRequestPath<Path extends keyof paths, Method extends AllowedMethod<Path>>({
+export function getRequestPath({
   path,
   pathParams,
   queryParams,
@@ -144,7 +91,7 @@ export function getRequestPath<Path extends keyof paths, Method extends AllowedM
   // method mention here so that it can be referenced in JSDoc
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   method: _,
-}: GetRequestPathOptions<Path, Method>): string {
+}: GetRequestPathOptions): string {
   // Step 1: Extract the path parameters (placeholders) from the path
   const placeholders = Array.from(path.matchAll(/{(.*?)}/g)).map((match) => match[1])