celitech-sdk 1.3.60 → 1.3.63

package/dist/index.mjs

@@ -1,8 +1,14 @@
 // src/http/handlers/handler-chain.ts
 var RequestHandlerChain = class {
   constructor() {
+    /** Array of handlers in the chain */
     this.handlers = [];
   }
+  /**
+   * Adds a handler to the end of the chain.
+   * Links the new handler to the previous one in the chain.
+   * @param handler - The request handler to add
+   */
   addHandler(handler) {
     if (this.handlers.length > 0) {
       const previousHandler = this.handlers[this.handlers.length - 1];
@@ -10,12 +16,26 @@ var RequestHandlerChain = class {
     }
     this.handlers.push(handler);
   }
+  /**
+   * Executes the handler chain for a standard request.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to process
+   * @returns A promise that resolves to the HTTP response
+   * @throws Error if no handlers are added to the chain
+   */
   async callChain(request) {
     if (!this.handlers.length) {
       throw new Error("No handlers added to the chain");
     }
     return this.handlers[0].handle(request);
   }
+  /**
+   * Executes the handler chain for a streaming request.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to process
+   * @returns An async generator that yields HTTP responses
+   * @throws Error if no handlers are added to the chain
+   */
   async *streamChain(request) {
     if (!this.handlers.length) {
       throw new Error("No handlers added to the chain");
@@ -26,6 +46,12 @@ var RequestHandlerChain = class {
 
 // src/http/error.ts
 var HttpError = class extends Error {
+  /**
+   * Creates a new HTTP error.
+   * @param metadata - HTTP response metadata
+   * @param raw - Raw response object (optional)
+   * @param error - Custom error message (optional, defaults to status text)
+   */
   constructor(metadata, raw, error) {
     super(error);
     this.error = metadata.statusText;
@@ -36,12 +62,35 @@ var HttpError = class extends Error {
 
 // src/http/hooks/custom-hook.ts
 var CustomHook = class {
+  /**
+   * Called before an HTTP request is sent.
+   * Default implementation returns the request unchanged.
+   * @param request - The HTTP request to be sent
+   * @param params - Additional custom parameters
+   * @returns A promise that resolves to the unmodified request
+   */
   async beforeRequest(request, params) {
     return request;
   }
+  /**
+   * Called after a successful HTTP response is received.
+   * Default implementation returns the response unchanged.
+   * @param request - The original HTTP request
+   * @param response - The HTTP response received
+   * @param params - Additional custom parameters
+   * @returns A promise that resolves to the unmodified response
+   */
   async afterResponse(request, response, params) {
     return response;
   }
+  /**
+   * Called when an HTTP request results in an error.
+   * Default implementation wraps the error response in an HttpError object.
+   * @param request - The original HTTP request
+   * @param response - The error response received
+   * @param params - Additional custom parameters
+   * @returns A promise that resolves to an HttpError object
+   */
   async onError(request, response, params) {
     return new HttpError(response.metadata, response.raw);
   }
@@ -49,6 +98,11 @@ var CustomHook = class {
 
 // src/http/serialization/base-serializer.ts
 var Serializer = class {
+  /**
+   * Serializes a parameter value based on its type and serialization style.
+   * @param param - The request parameter to serialize
+   * @returns The serialized string representation
+   */
   serializeValue(param) {
     if (Array.isArray(param.value)) {
       return this.serializeArray(param.value, param);
@@ -58,6 +112,11 @@ var Serializer = class {
     }
     return this.serializePrimitive(param);
   }
+  /**
+   * Serializes a primitive value (string, number, boolean).
+   * @param param - The request parameter containing the primitive value
+   * @returns The serialized primitive string
+   */
   serializePrimitive(param) {
     if (param.style === "label" /* LABEL */) {
       return `.${param.value}`;
@@ -68,6 +127,12 @@ var Serializer = class {
     }
     return `${param.value}`;
   }
+  /**
+   * Serializes an array value according to the specified style.
+   * @param value - The array to serialize
+   * @param param - The request parameter configuration
+   * @returns The serialized array string
+   */
   serializeArray(value, param) {
     if (param.explode) {
       this.serializeArrayExploded(value, param);
@@ -88,6 +153,12 @@ var Serializer = class {
     }
     return `${value.join(",")}`;
   }
+  /**
+   * Serializes an array in exploded format where each value is a separate parameter.
+   * @param value - The array to serialize
+   * @param param - The request parameter configuration
+   * @returns The serialized exploded array string
+   */
   serializeArrayExploded(value, param) {
     if (param.style === "simple" /* SIMPLE */) {
       return value.map((val) => `${val}`).join(",");
@@ -100,6 +171,12 @@ var Serializer = class {
     }
     return `${value.join(",")}`;
   }
+  /**
+   * Serializes an object value according to the specified style.
+   * @param obj - The object to serialize
+   * @param param - The request parameter configuration
+   * @returns The serialized object string
+   */
   serializeObject(obj, param) {
     if (param.explode) {
       if (param.style === "simple" /* SIMPLE */) {
@@ -127,6 +204,11 @@ var Serializer = class {
     }
     return Object.entries(obj).map(([key, val]) => `${key}=${val}`).join("&");
   }
+  /**
+   * Type guard to check if a value is a non-null object.
+   * @param value - The value to check
+   * @returns True if the value is an object and not null
+   */
   isNonNullObject(value) {
     return typeof value === "object" && value !== null;
   }
@@ -137,6 +219,14 @@ var TransportHookAdapter = class {
   constructor() {
     this.hook = new CustomHook();
   }
+  /**
+   * Invokes the custom hook before sending the request.
+   * Converts the Request to HttpRequest format, calls the hook, then converts back.
+   *
+   * @param request - The internal Request object
+   * @param params - Additional parameters to pass to the hook
+   * @returns The modified Request after hook processing
+   */
   async beforeRequest(request, params) {
     const hookRequest = this.requestToHookRequest(request);
     const newRequest = await this.hook.beforeRequest(hookRequest, params);
@@ -151,14 +241,39 @@ var TransportHookAdapter = class {
     });
     return newTransportRequest;
   }
+  /**
+   * Invokes the custom hook after receiving a response.
+   * Converts the Request to HttpRequest format and calls the hook with the response.
+   *
+   * @param request - The internal Request object
+   * @param response - The HTTP response received
+   * @param params - Additional parameters to pass to the hook
+   * @returns The potentially modified response after hook processing
+   */
   async afterResponse(request, response, params) {
     const hookRequest = this.requestToHookRequest(request);
     return this.hook.afterResponse(hookRequest, response, params);
   }
+  /**
+   * Invokes the custom hook when an error occurs.
+   * Converts the Request to HttpRequest format and calls the error hook.
+   *
+   * @param request - The internal Request object
+   * @param response - The HTTP response that triggered the error
+   * @param params - Additional parameters to pass to the hook
+   * @returns The HttpError from the hook
+   */
   async onError(request, response, params) {
     const hookRequest = this.requestToHookRequest(request);
     return this.hook.onError(hookRequest, response, params);
   }
+  /**
+   * Converts the internal Request representation to the hook's HttpRequest format.
+   * Extracts parameter values from RequestParameter wrappers.
+   *
+   * @param request - The internal Request object
+   * @returns An HttpRequest object for hook processing
+   */
   requestToHookRequest(request) {
     const hookHeaders = /* @__PURE__ */ new Map();
     request.headers.forEach((header, key) => {
@@ -183,10 +298,20 @@ var TransportHookAdapter = class {
     };
     return hookRequest;
   }
+  /**
+   * Converts hook parameter maps back to RequestParameter format.
+   * Preserves serialization metadata from the original parameters.
+   *
+   * @template T - The parameter value type
+   * @param hookParams - The parameter map from hook processing
+   * @param originalTransportParams - The original RequestParameter map for metadata
+   * @param encode - Whether to encode the parameters
+   * @returns A map of RequestParameter objects for transport
+   */
   hookParamsToTransportParams(hookParams, originalTransportParams, encode) {
     const transportParams = /* @__PURE__ */ new Map();
     hookParams.forEach((hookParamValue, hookParamKey) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e;
       const requestParam = originalTransportParams.get(hookParamKey);
       transportParams.set(hookParamKey, {
         key: hookParamKey,
@@ -195,7 +320,8 @@ var TransportHookAdapter = class {
         style: (requestParam == null ? void 0 : requestParam.style) || "none" /* NONE */,
         explode: (_b = requestParam == null ? void 0 : requestParam.explode) != null ? _b : false,
         isLimit: (_c = requestParam == null ? void 0 : requestParam.isLimit) != null ? _c : false,
-        isOffset: (_d = requestParam == null ? void 0 : requestParam.isOffset) != null ? _d : false
+        isOffset: (_d = requestParam == null ? void 0 : requestParam.isOffset) != null ? _d : false,
+        isCursor: (_e = requestParam == null ? void 0 : requestParam.isCursor) != null ? _e : false
       });
     });
     return transportParams;
@@ -214,19 +340,28 @@ function getContentTypeDefinition(contentType) {
   if (ct === "text/event-stream") {
     return "eventStream" /* EventStream */;
   }
+  if (ct === "application/json" || ct === "text/json" || ct.includes("+json")) {
+    return "json" /* Json */;
+  }
+  if (ct === "application/javascript") {
+    return "text" /* Text */;
+  }
   if (ct.startsWith("text/")) {
     return "text" /* Text */;
   }
+  if (ct === "image/svg+xml") {
+    return "text" /* Text */;
+  }
   if (ct.startsWith("image/")) {
     return "image" /* Image */;
   }
   if (ct === "application/octet-stream" || ct === "application/pdf") {
     return "binary" /* Binary */;
   }
-  if (ct === "application/json") {
-    return "json" /* Json */;
+  if (ct === "*/*") {
+    return "binary" /* Binary */;
   }
-  return "json" /* Json */;
+  return "binary" /* Binary */;
 }
 
 // src/http/handlers/hook-handler.ts
@@ -234,6 +369,14 @@ var HookHandler = class {
   constructor(hook) {
     this.hook = hook;
   }
+  /**
+   * Handles a standard HTTP request with hook invocation.
+   * Calls beforeRequest hook, processes the request, and calls afterResponse or onError hooks.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to process
+   * @returns A promise that resolves to the HTTP response
+   * @throws Error if no next handler is set, or if error handling fails
+   */
   async handle(request) {
     var _a;
     if (!this.next) {
@@ -246,6 +389,7 @@ var HookHandler = class {
     if (response.metadata.status < 400) {
       return await hook.afterResponse(nextRequest, response, hookParams);
     }
+    const arrayBuffer = response.raw;
     const rawContentType = ((_a = response.metadata.headers["content-type"]) == null ? void 0 : _a.toLocaleLowerCase()) || "";
     const contentType = getContentTypeDefinition(rawContentType);
     const statusCode = response.metadata.status;
@@ -253,19 +397,27 @@ var HookHandler = class {
       return error2.contentType === contentType && error2.status === statusCode;
     });
     if (error) {
-      const decodedBody2 = new TextDecoder().decode(response.raw);
+      const decodedBody2 = new TextDecoder().decode(arrayBuffer);
       const json = JSON.parse(decodedBody2);
       new error.error((json == null ? void 0 : json.message) || "", json).throw();
     }
-    const decodedBody = new TextDecoder().decode(response.raw);
+    const decodedBody = new TextDecoder().decode(arrayBuffer);
     throw new HttpError(
       response.metadata,
-      response.raw,
+      arrayBuffer,
       `Unexpected response body for error status.
 StatusCode: ${response.metadata.status}
 Body: ${decodedBody}`
     );
   }
+  /**
+   * Handles a streaming HTTP request with hook invocation.
+   * Calls beforeRequest hook and afterResponse/onError hooks for each chunk.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to process
+   * @returns An async generator that yields HTTP responses
+   * @throws Error if no next handler is set, or if error handling fails
+   */
   async *stream(request) {
     if (!this.next) {
       throw new Error("No next handler set in hook handler.");
@@ -282,6 +434,12 @@ Body: ${decodedBody}`
       }
     }
   }
+  /**
+   * Extracts hook parameters from the request configuration.
+   * @template T - The response data type
+   * @param request - The HTTP request
+   * @returns A map of hook parameter names to values
+   */
   getHookParams(_request) {
     const hookParams = /* @__PURE__ */ new Map();
     return hookParams;
@@ -293,9 +451,19 @@ import { ZodUndefined } from "zod";
 
 // src/http/utils/response-matcher.ts
 var ResponseMatcher = class {
+  /**
+   * Creates a new response matcher.
+   * @param responses - Array of possible response definitions for an endpoint
+   */
   constructor(responses) {
     this.responses = responses;
   }
+  /**
+   * Finds the matching response definition for an HTTP response.
+   * Matches based on status code and content type from the response headers.
+   * @param response - The HTTP response to match
+   * @returns The matching response definition, or undefined if no match found
+   */
   getResponseDefinition(response) {
     var _a;
     const rawContentType = ((_a = response.metadata.headers["content-type"]) == null ? void 0 : _a.toLocaleLowerCase()) || "";
@@ -315,10 +483,23 @@ var ResponseMatcher = class {
 
 // src/http/handlers/response-validation-handler.ts
 var ResponseValidationHandler = class {
+  /**
+   * Handles a standard HTTP request and validates its response.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to process
+   * @returns A promise that resolves to the validated HTTP response
+   */
   async handle(request) {
     const response = await this.next.handle(request);
     return this.decodeBody(request, response);
   }
+  /**
+   * Handles a streaming HTTP request and validates response chunks.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to process
+   * @returns An async generator that yields validated HTTP responses
+   * @throws Error if response headers are enabled (streaming not supported with headers)
+   */
   async *stream(request) {
     const stream = this.next.stream(request);
     for await (const response of stream) {
@@ -329,7 +510,8 @@ var ResponseValidationHandler = class {
     }
   }
   splitByDataChunks(response) {
-    if (!response.metadata.headers["content-type"].includes("text/event-stream")) {
+    var _a;
+    if (!((_a = response.metadata.headers["content-type"]) == null ? void 0 : _a.includes("text/event-stream"))) {
       return [response];
     }
     const text = new TextDecoder().decode(response.raw);
@@ -411,6 +593,14 @@ var ResponseValidationHandler = class {
       data: this.validate(request, responseDefinition, json)
     };
   }
+  /**
+   * Validates response data against the expected schema if validation is enabled.
+   * @template T - The expected data type
+   * @param request - The HTTP request containing validation settings
+   * @param response - The response definition with schema
+   * @param data - The data to validate
+   * @returns The validated data (parsed if validation enabled, raw otherwise)
+   */
   validate(request, response, data) {
     var _a;
     if ((_a = request.validation) == null ? void 0 : _a.responseValidation) {
@@ -418,9 +608,21 @@ var ResponseValidationHandler = class {
     }
     return data;
   }
+  /**
+   * Checks if a response should contain data based on its schema and status.
+   * @template T - The response data type
+   * @param responseDefinition - The response definition
+   * @param response - The HTTP response
+   * @returns True if the response should have content, false otherwise
+   */
   hasContent(responseDefinition, response) {
     return !!responseDefinition.schema && !(responseDefinition.schema instanceof ZodUndefined) && response.metadata.status !== 204;
   }
+  /**
+   * Parses URL-encoded data into an object.
+   * @param urlEncodedData - The URL-encoded string
+   * @returns An object with decoded key-value pairs
+   */
   fromUrlEncoded(urlEncodedData) {
     const pairs = urlEncodedData.split("&");
     const result = {};
@@ -432,6 +634,11 @@ var ResponseValidationHandler = class {
     });
     return result;
   }
+  /**
+   * Parses multipart form data into an object.
+   * @param arrayBuffer - The raw form data as ArrayBuffer
+   * @returns An object with form field names and values
+   */
   fromFormData(arrayBuffer) {
     const decoder = new TextDecoder();
     const text = decoder.decode(arrayBuffer);
@@ -455,6 +662,11 @@ import { ZodError } from "zod";
 
 // src/http/errors/validation-error.ts
 var ValidationError = class extends Error {
+  /**
+   * Creates a new validation error from a Zod error.
+   * @param zodError - The Zod validation error containing issue details
+   * @param object - The object that failed validation
+   */
   constructor(zodError, object) {
     let actual;
     try {
@@ -475,6 +687,13 @@ var ValidationError = class extends Error {
 
 // src/http/handlers/request-validation-handler.ts
 var RequestValidationHandler = class {
+  /**
+   * Handles a standard HTTP request with validation.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to validate
+   * @returns A promise that resolves to the HTTP response
+   * @throws Error if no next handler is set
+   */
   async handle(request) {
     if (!this.next) {
       throw new Error("No next handler set in ContentTypeHandler.");
@@ -482,6 +701,13 @@ var RequestValidationHandler = class {
     this.validateRequest(request);
     return this.next.handle(request);
   }
+  /**
+   * Handles a streaming HTTP request with validation.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to validate
+   * @returns An async generator that yields HTTP responses
+   * @throws Error if no next handler is set
+   */
   async *stream(request) {
     if (!this.next) {
       throw new Error("No next handler set in ContentTypeHandler.");
@@ -489,6 +715,11 @@ var RequestValidationHandler = class {
     this.validateRequest(request);
     yield* this.next.stream(request);
   }
+  /**
+   * Validates and serializes the request body based on its content type.
+   * @param request - The HTTP request to validate
+   * @throws ValidationError if Zod schema validation fails
+   */
   validateRequest(request) {
     var _a, _b;
     if (request.requestContentType === "json" /* Json */) {
@@ -511,6 +742,11 @@ var RequestValidationHandler = class {
       request.body = JSON.stringify((_b = request.requestSchema) == null ? void 0 : _b.parse(request.body));
     }
   }
+  /**
+   * Converts request body to URL-encoded form data format.
+   * @param request - The HTTP request with body to convert
+   * @returns URL-encoded string representation of the body
+   */
   toFormUrlEncoded(request) {
     var _a;
     if (request.body === void 0) {
@@ -543,6 +779,14 @@ var RequestValidationHandler = class {
     }
     return "";
   }
+  /**
+   * Converts request body to multipart form data format.
+   * Handles files (ArrayBuffer), arrays, and regular values.
+   * @param body - The request body object
+   * @param filename - Optional filename for single file uploads
+   * @param filenames - Optional filenames array for array of file uploads
+   * @returns FormData object with serialized body
+   */
   toFormData(body, filename, filenames) {
     const formData = new FormData();
     Object.keys(body).forEach((key) => {
@@ -577,6 +821,9 @@ var LineDecoder = class {
   /**
    * Splits the given chunk into lines.
    * Stores incomplete lines in a buffer and returns them when the next chunk arrives.
+   *
+   * @param chunk - The data chunk to split into lines
+   * @returns An array of complete lines as Uint8Array
    */
   splitLines(chunk) {
     this.lineBuffer += this.decoder.decode(chunk);
@@ -591,7 +838,12 @@ var LineDecoder = class {
     }
     return lines;
   }
-  /** Returns the remaining lines in the buffer. */
+  /**
+   * Returns the remaining lines in the buffer.
+   * Call this after the stream ends to get any incomplete final line.
+   *
+   * @returns An array containing the buffered line, or empty if buffer is empty
+   */
   flush() {
     if (this.lineBuffer.length === 0) {
       return [];
@@ -609,9 +861,16 @@ var RequestFetchAdapter = class {
     this.requestInit = {};
     this.setMethod(request.method);
     this.setHeaders(request.getHeaders());
+    this.setCookies(request.getCookies());
     this.setBody(request.body);
     this.setTimeout(request.config.timeoutMs);
   }
+  /**
+   * Executes the HTTP request and returns the response.
+   * Fetches the full response body as an ArrayBuffer.
+   *
+   * @returns A promise resolving to the HTTP response with metadata and body
+   */
   async send() {
     const response = await fetch(this.request.constructFullUrl(), this.requestInit);
     const metadata = {
@@ -624,6 +883,13 @@ var RequestFetchAdapter = class {
       raw: await response.clone().arrayBuffer()
     };
   }
+  /**
+   * Executes the HTTP request as a stream, yielding chunks as they arrive.
+   * Uses the Fetch API's ReadableStream and LineDecoder to split into lines.
+   *
+   * @returns An async generator yielding HTTP response chunks
+   * @throws Error if responseHeaders is enabled (streaming not supported with responseHeaders)
+   */
   async *stream() {
     const response = await fetch(this.request.constructFullUrl(), this.requestInit);
     const metadata = {
@@ -688,6 +954,19 @@ var RequestFetchAdapter = class {
       headers
     };
   }
+  setCookies(cookies) {
+    if (!cookies || Object.keys(cookies).length === 0) {
+      return;
+    }
+    const cookieString = Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
+    this.requestInit = {
+      ...this.requestInit,
+      headers: {
+        ...this.requestInit.headers,
+        Cookie: cookieString
+      }
+    };
+  }
   setTimeout(timeoutMs) {
     if (!timeoutMs) {
       return;
@@ -711,9 +990,21 @@ var RequestFetchAdapter = class {
 
 // src/http/handlers/terminating-handler.ts
 var TerminatingHandler = class {
+  /**
+   * Executes the actual HTTP request using the configured client adapter.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to execute
+   * @returns A promise that resolves to the HTTP response
+   */
   async handle(request) {
     return new RequestFetchAdapter(request).send();
   }
+  /**
+   * Executes a streaming HTTP request using the configured client adapter.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to execute
+   * @returns An async generator that yields HTTP responses
+   */
   async *stream(request) {
     yield* new RequestFetchAdapter(request).stream();
   }
@@ -721,6 +1012,14 @@ var TerminatingHandler = class {
 
 // src/http/handlers/retry-handler.ts
 var RetryHandler = class {
+  /**
+   * Handles a standard HTTP request with retry logic.
+   * Retries failed requests based on the configured retry settings.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to process
+   * @returns A promise that resolves to the HTTP response
+   * @throws Error if no next handler is set, or if all retry attempts fail
+   */
   async handle(request) {
     if (!this.next) {
       throw new Error("No next handler set in retry handler.");
@@ -737,6 +1036,13 @@ var RetryHandler = class {
     }
     throw new Error("Error retrying request.");
   }
+  /**
+   * Handles a streaming HTTP request with retry logic.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to process
+   * @returns An async generator that yields HTTP responses
+   * @throws Error if no next handler is set, or if all retry attempts fail
+   */
   async *stream(request) {
     if (!this.next) {
       throw new Error("No next handler set in retry handler.");
@@ -754,9 +1060,20 @@ var RetryHandler = class {
     }
     throw new Error("Error retrying request.");
   }
+  /**
+   * Determines if an error should trigger a retry.
+   * Retries server errors (5xx), request timeouts (408), and rate limits (429).
+   * @param error - The error to check
+   * @returns True if the request should be retried, false otherwise
+   */
   shouldRetry(error) {
-    return error instanceof HttpError && (error.metadata.status >= 500 || error.metadata.status === 408);
+    return error instanceof HttpError && (error.metadata.status >= 500 || error.metadata.status === 408 || error.metadata.status === 429);
   }
+  /**
+   * Delays execution for a specified duration before retrying.
+   * @param delayMs - The delay in milliseconds (optional)
+   * @returns A promise that resolves after the delay
+   */
   delay(delayMs) {
     if (!delayMs) {
       return Promise.resolve();
@@ -767,8 +1084,21 @@ var RetryHandler = class {
   }
 };
 
+// src/http/transport/types.ts
+function isRequestCursorPagination(pagination) {
+  return !!pagination && "cursorPath" in pagination;
+}
+
 // src/http/handlers/oauth-handler.ts
 var OAuthHandler = class {
+  /**
+   * Handles a standard HTTP request with OAuth authentication.
+   * Manages access tokens and adds Authorization headers.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to process
+   * @returns A promise that resolves to the HTTP response
+   * @throws Error if no next handler is set
+   */
   async handle(request) {
     if (!this.next) {
       throw new Error(`No next handler set in OAuthHandler`);
@@ -783,6 +1113,13 @@ var OAuthHandler = class {
     await this.manageToken(request);
     return this.next.handle(request);
   }
+  /**
+   * Handles a streaming HTTP request with OAuth authentication.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to process
+   * @returns An async generator that yields HTTP responses
+   * @throws Error if no next handler is set
+   */
   async *stream(request) {
     if (!this.next) {
       throw new Error(`No next handler set in OAuthHandler`);
@@ -790,6 +1127,10 @@ var OAuthHandler = class {
     await this.manageToken(request);
     yield* this.next.stream(request);
   }
+  /**
+   * Retrieves an access token for the required scopes and adds it to the request.
+   * @param request - The HTTP request to add the token to
+   */
   async manageToken(request) {
     if (!request.scopes) {
       return;
@@ -799,6 +1140,11 @@ var OAuthHandler = class {
       this.addAccessTokenHeader(request, token.accessToken);
     }
   }
+  /**
+   * Adds the OAuth access token to the request's Authorization header.
+   * @param request - The HTTP request to modify
+   * @param token - The access token to add
+   */
   addAccessTokenHeader(request, token) {
     request.addHeaderParam("Authorization", {
       key: "Authorization",
@@ -807,15 +1153,22 @@ var OAuthHandler = class {
       encode: false,
       style: "simple" /* SIMPLE */,
       isLimit: false,
-      isOffset: false
+      isOffset: false,
+      isCursor: false
     });
   }
 };
 
 // src/http/client.ts
 var HttpClient = class {
+  /**
+   * Creates a new HTTP client with configured request handlers.
+   * @param config - SDK configuration including base URL and authentication
+   * @param hook - Optional custom hook for request/response interception
+   */
   constructor(config, hook = new CustomHook()) {
     this.config = config;
+    /** Chain of request handlers that process requests in sequence */
     this.requestHandlerChain = new RequestHandlerChain();
     this.requestHandlerChain.addHandler(new ResponseValidationHandler());
     this.requestHandlerChain.addHandler(new RequestValidationHandler());
@@ -824,45 +1177,126 @@ var HttpClient = class {
     this.requestHandlerChain.addHandler(new HookHandler(hook));
     this.requestHandlerChain.addHandler(new TerminatingHandler());
   }
+  /**
+   * Executes a standard HTTP request.
+   * @template T - The expected response data type
+   * @param request - The HTTP request to execute
+   * @returns A promise that resolves to the HTTP response
+   */
   call(request) {
     return this.requestHandlerChain.callChain(request);
   }
+  /**
+   * Executes a streaming HTTP request that yields responses incrementally.
+   * @template T - The expected response data type for each chunk
+   * @param request - The HTTP request to execute
+   * @returns An async generator that yields HTTP responses
+   */
   async *stream(request) {
     yield* this.requestHandlerChain.streamChain(request);
   }
+  /**
+   * Executes a paginated HTTP request and extracts the page data from the response.
+   * @template FullResponse - The complete response type from the API
+   * @template Page - The type of a single page of data
+   * @param request - The paginated HTTP request to execute
+   * @returns A promise that resolves to the paginated HTTP response
+   * @throws Error if the response contains no data to paginate through
+   */
   async callPaginated(request) {
     const response = await this.call(request);
     if (!response.data) {
       throw new Error("no response data to paginate through");
     }
+    const page = this.getPage(request, response.data);
     return {
       ...response,
-      data: this.getPage(request, response.data)
+      data: page
     };
   }
+  /**
+   * Executes a cursor-paginated HTTP request and extracts both page data and the next cursor.
+   * @template FullResponse - The complete response type from the API
+   * @template Page - The type of a single page of data
+   * @param request - The cursor-paginated HTTP request to execute
+   * @returns A promise that resolves to the cursor-paginated HTTP response with next cursor
+   * @throws Error if the response contains no data to paginate through
+   */
+  async callCursorPaginated(request) {
+    const response = await this.call(request);
+    if (!response.data) {
+      throw new Error("no response data to paginate through");
+    }
+    const page = this.getPage(request, response.data);
+    const nextCursor = this.getNextCursor(request, response.data);
+    return {
+      ...response,
+      data: page,
+      nextCursor
+    };
+  }
+  /**
+   * Updates the base URL for all subsequent requests.
+   * @param url - The new base URL to use
+   */
   setBaseUrl(url) {
     this.config.baseUrl = url;
   }
+  /**
+   * Updates the SDK configuration.
+   * @param config - The new SDK configuration
+   */
   setConfig(config) {
     this.config = config;
   }
+  /**
+   * Extracts page data from a full API response using the configured pagination path.
+   * @template FullResponse - The complete response type from the API
+   * @template Page - The type of a single page of data
+   * @param request - The request containing pagination configuration
+   * @param data - The full response data to extract the page from
+   * @returns The extracted and parsed page data
+   * @throws Error if pagination is not configured or page extraction fails
+   */
   getPage(request, data) {
-    var _a, _b, _c, _d;
+    var _a;
     if (!request.pagination) {
       throw new Error("getPage called for request without pagination property");
     }
     let curr = data;
-    for (const segment of ((_a = request.pagination) == null ? void 0 : _a.pagePath) || []) {
+    for (const segment of request.pagination.pagePath || []) {
       curr = curr[segment];
     }
-    const page = (_c = (_b = request.pagination) == null ? void 0 : _b.pageSchema) == null ? void 0 : _c.parse(curr);
+    const page = (_a = request.pagination.pageSchema) == null ? void 0 : _a.parse(curr);
     if (!page) {
       throw new Error(
-        `error getting page data. Curr: ${JSON.stringify(curr)}. PagePath: ${(_d = request.pagination) == null ? void 0 : _d.pagePath}. Data: ${JSON.stringify(data)}`
+        `error getting page data. Curr: ${JSON.stringify(curr)}. PagePath: ${request.pagination.pagePath}. Data: ${JSON.stringify(data)}`
       );
     }
     return page;
   }
+  /**
+   * Extracts the next cursor from a full API response for cursor-based pagination.
+   * @template FullResponse - The complete response type from the API
+   * @template Page - The type of a single page of data
+   * @param request - The request containing cursor pagination configuration
+   * @param data - The full response data to extract the cursor from
+   * @returns The next cursor string, null if no more pages, or undefined if not cursor pagination
+   */
+  getNextCursor(request, data) {
+    var _a, _b;
+    if (!isRequestCursorPagination(request.pagination)) {
+      return void 0;
+    }
+    let curr = data;
+    for (const segment of request.pagination.cursorPath) {
+      if (curr === null || curr === void 0) {
+        return null;
+      }
+      curr = curr[segment];
+    }
+    return (_b = (_a = request.pagination.cursorSchema) == null ? void 0 : _a.parse(curr)) != null ? _b : null;
+  }
 };
 
 // src/services/base-service.ts
@@ -900,6 +1334,14 @@ import z from "zod";
 
 // src/http/serialization/path-serializer.ts
 var PathSerializer = class extends Serializer {
+  /**
+   * Serializes path parameters into a URL path by replacing template placeholders.
+   * @param pathPattern - The URL path pattern with {placeholders}
+   * @param pathArguments - Map of parameter names to their values
+   * @returns The path with placeholders replaced by serialized values
+   * @example
+   * serialize("/users/{id}", Map([["id", {key: "id", value: 123}]])) returns "/users/123"
+   */
   serialize(pathPattern, pathArguments) {
     let serializedPath = pathPattern;
     pathArguments.forEach((param) => {
@@ -911,12 +1353,22 @@ var PathSerializer = class extends Serializer {
 
 // src/http/serialization/query-serializer.ts
 var QuerySerializer = class extends Serializer {
+  /**
+   * Serializes query parameters into a URL query string.
+   * @param queryParams - Map of query parameter names to their values
+   * @returns A query string starting with "?" if parameters exist, empty string otherwise
+   * @example
+   * serialize(Map([["name", {...}], ["age", {...}]])) returns "?name=John&age=30"
+   */
   serialize(queryParams) {
     if (!queryParams || !queryParams.size) {
       return "";
     }
     const query = [];
     queryParams.forEach((param) => {
+      if (param.value === void 0) {
+        return;
+      }
       return query.push(`${this.serializeValue(param)}`);
     });
     return query.length ? `?${query.join("&")}` : "";
@@ -925,6 +1377,11 @@ var QuerySerializer = class extends Serializer {
 
 // src/http/serialization/header-serializer.ts
 var HeaderSerializer = class extends Serializer {
+  /**
+   * Serializes header parameters into a headers object.
+   * @param headerParams - Map of header names to their parameter values
+   * @returns A HeadersInit object with serialized header values, or undefined if no headers
+   */
   serialize(headerParams) {
     if (!headerParams || !headerParams.size) {
       return void 0;
@@ -940,6 +1397,83 @@ var HeaderSerializer = class extends Serializer {
   }
 };
 
+// src/http/serialization/cookie-serializer.ts
+var CookieSerializer = class {
+  /**
+   * Serializes cookie parameters into a cookie object.
+   * @param cookieParams - Map of cookie names to their parameter values
+   * @returns A record of cookie names to serialized values, or undefined if no cookies
+   */
+  serialize(cookieParams) {
+    if (!cookieParams || !cookieParams.size) {
+      return void 0;
+    }
+    const cookies = {};
+    cookieParams.forEach((param) => {
+      if (!param.key || param.value === void 0) {
+        return;
+      }
+      cookies[param.key] = this.serializeCookieValue(param);
+    });
+    return cookies;
+  }
+  /**
+   * Serializes a single cookie value based on its type.
+   * @param param - The cookie parameter to serialize
+   * @returns The serialized cookie value string
+   */
+  serializeCookieValue(param) {
+    if (Array.isArray(param.value)) {
+      return this.serializeArray(param.value, param);
+    }
+    if (this.isNonNullObject(param.value)) {
+      return this.serializeObject(param.value, param);
+    }
+    return this.serializePrimitive(param.value);
+  }
+  /**
+   * Serializes a primitive cookie value.
+   * @param value - The primitive value to serialize
+   * @returns The string representation of the value
+   */
+  serializePrimitive(value) {
+    return `${value}`;
+  }
+  /**
+   * Serializes an array cookie value.
+   * @param value - The array to serialize
+   * @param param - The cookie parameter configuration
+   * @returns The serialized array string
+   */
+  serializeArray(value, param) {
+    if (param.explode) {
+      if (value.length === 0)
+        return "";
+      const first = value[0];
+      const rest = value.slice(1).map((v) => `${param.key}=${v}`).join("; ");
+      return rest ? `${first}; ${rest}` : `${first}`;
+    }
+    return value.join(",");
+  }
+  /**
+   * Serializes an object cookie value as JSON.
+   * @param obj - The object to serialize
+   * @param param - The cookie parameter configuration
+   * @returns The JSON string representation of the object
+   */
+  serializeObject(obj, param) {
+    return JSON.stringify(obj);
+  }
+  /**
+   * Type guard to check if a value is a non-null object.
+   * @param value - The value to check
+   * @returns True if the value is an object and not null
+   */
+  isNonNullObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+};
+
 // src/http/transport/request.ts
 var Request = class {
   constructor(params) {
@@ -947,6 +1481,7 @@ var Request = class {
     this.headers = /* @__PURE__ */ new Map();
     this.queryParams = /* @__PURE__ */ new Map();
     this.pathParams = /* @__PURE__ */ new Map();
+    this.cookies = /* @__PURE__ */ new Map();
     this.validation = {};
     this.retry = {};
     this.baseUrl = params.baseUrl;
@@ -958,6 +1493,7 @@ var Request = class {
     this.pathParams = params.pathParams;
     this.headers = params.headers;
     this.queryParams = params.queryParams;
+    this.cookies = params.cookies;
     this.responses = params.responses;
     this.errors = params.errors;
     this.requestSchema = params.requestSchema;
@@ -970,6 +1506,12 @@ var Request = class {
     this.scopes = params.scopes;
     this.tokenManager = params.tokenManager;
   }
+  /**
+   * Adds a header parameter to the request with OpenAPI serialization rules.
+   *
+   * @param key - The header name
+   * @param param - The parameter configuration including value, style, and encoding options
+   */
   addHeaderParam(key, param) {
     if (param.value === void 0) {
       return;
@@ -985,6 +1527,12 @@ var Request = class {
     }
     this.headers.set(key, param);
   }
+  /**
+   * Adds a query parameter to the request with OpenAPI serialization rules.
+   *
+   * @param key - The query parameter name
+   * @param param - The parameter configuration including value, style, and encoding options
+   */
   addQueryParam(key, param) {
     if (param.value === void 0) {
       return;
@@ -1000,6 +1548,12 @@ var Request = class {
     }
     this.queryParams.set(key, param);
   }
+  /**
+   * Adds a path parameter to the request with OpenAPI serialization rules.
+   *
+   * @param key - The path parameter name (matches template variable in path pattern)
+   * @param param - The parameter configuration including value, style, and encoding options
+   */
   addPathParam(key, param) {
     if (param.value === void 0) {
       return;
@@ -1015,26 +1569,50 @@ var Request = class {
     }
     this.pathParams.set(key, param);
   }
+  /**
+   * Sets the request body if the value is defined.
+   *
+   * @param body - The request body to send
+   */
   addBody(body) {
     if (body === void 0) {
       return;
     }
     this.body = body;
   }
+  /**
+   * Updates this request from a modified hook request.
+   * Used after hooks modify the request to sync changes back to the internal Request object.
+   *
+   * @param hookRequest - The modified request from hook processing
+   */
   updateFromHookRequest(hookRequest) {
     this.baseUrl = hookRequest.baseUrl;
     this.method = hookRequest.method;
     this.path = hookRequest.path;
     this.body = hookRequest.body;
   }
+  /**
+   * Constructs the complete URL by combining base URL, path with substituted parameters,
+   * and serialized query string.
+   *
+   * @returns The fully constructed URL ready for HTTP execution
+   */
   constructFullUrl() {
     const queryString = new QuerySerializer().serialize(this.queryParams);
     const path = this.constructPath();
     let baseUrl = this.baseUrl;
     return `${baseUrl}${path}${queryString}`;
   }
+  /**
+   * Creates a copy of this request with optional parameter overrides.
+   * Useful for pagination where you need to modify parameters while keeping the rest intact.
+   *
+   * @param overrides - Optional parameters to override in the copied request
+   * @returns A new Request instance with the specified overrides
+   */
   copy(overrides) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
     const createRequestParams = {
       baseUrl: (_a = overrides == null ? void 0 : overrides.baseUrl) != null ? _a : this.baseUrl,
       errors: (_b = overrides == null ? void 0 : overrides.errors) != null ? _b : this.errors,
@@ -1045,13 +1623,14 @@ var Request = class {
       pathParams: (_g = overrides == null ? void 0 : overrides.pathParams) != null ? _g : this.pathParams,
       queryParams: (_h = overrides == null ? void 0 : overrides.queryParams) != null ? _h : this.queryParams,
       headers: (_i = overrides == null ? void 0 : overrides.headers) != null ? _i : this.headers,
-      responses: (_j = overrides == null ? void 0 : overrides.responses) != null ? _j : this.responses,
-      requestSchema: (_k = overrides == null ? void 0 : overrides.requestSchema) != null ? _k : this.requestSchema,
-      requestContentType: (_l = overrides == null ? void 0 : overrides.requestContentType) != null ? _l : this.requestContentType,
-      retry: (_m = overrides == null ? void 0 : overrides.retry) != null ? _m : this.retry,
-      validation: (_n = overrides == null ? void 0 : overrides.validation) != null ? _n : this.validation,
-      filename: (_o = overrides == null ? void 0 : overrides.filename) != null ? _o : this.filename,
-      filenames: (_p = overrides == null ? void 0 : overrides.filenames) != null ? _p : this.filenames,
+      cookies: (_j = overrides == null ? void 0 : overrides.cookies) != null ? _j : this.cookies,
+      responses: (_k = overrides == null ? void 0 : overrides.responses) != null ? _k : this.responses,
+      requestSchema: (_l = overrides == null ? void 0 : overrides.requestSchema) != null ? _l : this.requestSchema,
+      requestContentType: (_m = overrides == null ? void 0 : overrides.requestContentType) != null ? _m : this.requestContentType,
+      retry: (_n = overrides == null ? void 0 : overrides.retry) != null ? _n : this.retry,
+      validation: (_o = overrides == null ? void 0 : overrides.validation) != null ? _o : this.validation,
+      filename: (_p = overrides == null ? void 0 : overrides.filename) != null ? _p : this.filename,
+      filenames: (_q = overrides == null ? void 0 : overrides.filenames) != null ? _q : this.filenames,
       scopes: overrides == null ? void 0 : overrides.scopes,
       tokenManager: this.tokenManager
     };
@@ -1060,21 +1639,52 @@ var Request = class {
       ...overrides
     });
   }
+  /**
+   * Serializes headers to a format suitable for HTTP execution.
+   *
+   * @returns Serialized headers as HeadersInit, or undefined if no headers
+   */
   getHeaders() {
     if (!this.headers || !this.headers.size) {
       return void 0;
     }
     return new HeaderSerializer().serialize(this.headers);
   }
-  nextPage() {
+  /**
+   * Serializes cookies to a format suitable for HTTP execution.
+   *
+   * @returns Serialized cookies as a record, or undefined if no cookies
+   */
+  getCookies() {
+    if (!this.cookies || !this.cookies.size) {
+      return void 0;
+    }
+    return new CookieSerializer().serialize(this.cookies);
+  }
+  /**
+   * Advances pagination parameters to fetch the next page.
+   * Handles both cursor-based and limit-offset pagination strategies.
+   *
+   * @param cursor - The cursor value for cursor-based pagination (optional for limit-offset)
+   */
+  nextPage(cursor) {
     if (!this.pagination) {
       return;
     }
-    const offsetParam = this.getOffsetParam();
-    if (!offsetParam) {
+    if (isRequestCursorPagination(this.pagination)) {
+      const cursorParam = this.getCursorParam();
+      if (cursorParam && cursor !== void 0) {
+        cursorParam.value = cursor;
+      }
       return;
     }
-    offsetParam.value = Number(offsetParam.value) + this.pagination.pageSize;
+    const offsetParam = this.getOffsetParam();
+    if (offsetParam) {
+      if (this.pagination.pageSize === void 0) {
+        throw new Error("pageSize is required for limit-offset pagination");
+      }
+      offsetParam.value = Number(offsetParam.value) + this.pagination.pageSize;
+    }
   }
   constructPath() {
     return new PathSerializer().serialize(this.pathPattern, this.pathParams);
@@ -1083,6 +1693,10 @@ var Request = class {
     const offsetParam = this.getAllParams().find((param) => param.isOffset);
     return offsetParam;
   }
+  getCursorParam() {
+    const cursorParam = this.getAllParams().find((param) => param.isCursor);
+    return cursorParam;
+  }
   getAllParams() {
     const allParams = [];
     this.headers.forEach((val, _) => {
@@ -1094,6 +1708,9 @@ var Request = class {
     this.pathParams.forEach((val, _) => {
       allParams.push(val);
     });
+    this.cookies.forEach((val, _) => {
+      allParams.push(val);
+    });
     return allParams;
   }
 };
@@ -1106,6 +1723,10 @@ var Environment = /* @__PURE__ */ ((Environment2) => {
 
 // src/http/transport/request-builder.ts
 var RequestBuilder = class {
+  /**
+   * Creates a new request builder with default configuration.
+   * Initializes retry settings, validation options, and empty parameter collections.
+   */
   constructor() {
     this.params = {
       baseUrl: "https://api.celitech.net/v1" /* DEFAULT */,
@@ -1126,6 +1747,7 @@ var RequestBuilder = class {
       pathParams: /* @__PURE__ */ new Map(),
       queryParams: /* @__PURE__ */ new Map(),
       headers: /* @__PURE__ */ new Map(),
+      cookies: /* @__PURE__ */ new Map(),
       tokenManager: new OAuthTokenManager()
     };
   }
@@ -1198,6 +1820,10 @@ var RequestBuilder = class {
     this.params.pagination = pagination;
     return this;
   }
+  setCursorPagination(pagination) {
+    this.params.pagination = pagination;
+    return this;
+  }
   setScopes(scopes) {
     this.params.scopes = new Set(scopes);
     return this;
@@ -1217,7 +1843,8 @@ var RequestBuilder = class {
       style: "simple" /* SIMPLE */,
       encode: true,
       isLimit: false,
-      isOffset: false
+      isOffset: false,
+      isCursor: false
     });
     return this;
   }
@@ -1232,7 +1859,8 @@ var RequestBuilder = class {
       style: "simple" /* SIMPLE */,
       encode: true,
       isLimit: false,
-      isOffset: false
+      isOffset: false,
+      isCursor: false
     });
     return this;
   }
@@ -1247,7 +1875,8 @@ var RequestBuilder = class {
       style: "simple" /* SIMPLE */,
       encode: true,
       isLimit: false,
-      isOffset: false
+      isOffset: false,
+      isCursor: false
     });
     return this;
   }
@@ -1277,13 +1906,14 @@ var RequestBuilder = class {
       style: (_b = param.style) != null ? _b : "simple" /* SIMPLE */,
       encode: (_c = param.encode) != null ? _c : true,
       isLimit: !!param.isLimit,
-      isOffset: !!param.isOffset
+      isOffset: !!param.isOffset,
+      isCursor: !!param.isCursor
     });
     return this;
   }
   addQueryParam(param) {
     var _a, _b, _c;
-    if (param.value === void 0 || param.key === void 0) {
+    if (param.key === void 0) {
       return this;
     }
     this.params.queryParams.set(param.key, {
@@ -1293,7 +1923,8 @@ var RequestBuilder = class {
       style: (_b = param.style) != null ? _b : "form" /* FORM */,
       encode: (_c = param.encode) != null ? _c : true,
       isLimit: !!param.isLimit,
-      isOffset: !!param.isOffset
+      isOffset: !!param.isOffset,
+      isCursor: !!param.isCursor
     });
     return this;
   }
@@ -1309,13 +1940,42 @@ var RequestBuilder = class {
       style: (_b = param.style) != null ? _b : "simple" /* SIMPLE */,
       encode: (_c = param.encode) != null ? _c : false,
       isLimit: !!param.isLimit,
-      isOffset: !!param.isOffset
+      isOffset: !!param.isOffset,
+      isCursor: !!param.isCursor
+    });
+    return this;
+  }
+  addCookieParam(param) {
+    var _a, _b, _c;
+    if (param.value === void 0 || param.key === void 0) {
+      return this;
+    }
+    this.params.cookies.set(param.key, {
+      key: param.key,
+      value: param.value,
+      explode: (_a = param.explode) != null ? _a : true,
+      style: (_b = param.style) != null ? _b : "form" /* FORM */,
+      encode: (_c = param.encode) != null ? _c : false,
+      isLimit: !!param.isLimit,
+      isOffset: !!param.isOffset,
+      isCursor: !!param.isCursor
     });
     return this;
   }
+  /**
+   * Builds and returns the configured Request object.
+   * Call this method after configuring all request parameters.
+   * @returns A new Request instance with all configured parameters
+   */
   build() {
     return new Request(this.params);
   }
+  /**
+   * Converts a string to Base64 encoding.
+   * Works in both Node.js and browser environments.
+   * @param str - The string to encode
+   * @returns The Base64-encoded string
+   */
   toBase64(str) {
     if (typeof window === "undefined") {
       return Buffer.from(str, "utf-8").toString("base64");
@@ -1393,8 +2053,8 @@ var getAccessTokenOkResponseRequest = z3.lazy(() => {
 var OAuthService = class extends BaseService {
   /**
    * This endpoint was added by liblab
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<GetAccessTokenOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetAccessTokenOkResponse>>} - Successful Response
    */
   async getAccessToken(body, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/oauth2/token").setRequestSchema(getAccessTokenRequestRequest).setTokenManager(this.tokenManager).setRequestContentType("form" /* FormUrlEncoded */).addResponse({
@@ -1414,11 +2074,22 @@ var GrantType = /* @__PURE__ */ ((GrantType2) => {
 
 // src/http/oauth/token-manager.ts
 var OAuthToken = class {
+  /**
+   * Creates a new OAuth token.
+   * @param accessToken - The access token string
+   * @param scopes - Set of OAuth scopes granted to this token
+   * @param expiresAt - Timestamp when the token expires (milliseconds since epoch), or null if no expiration
+   */
   constructor(accessToken, scopes, expiresAt) {
     this.accessToken = accessToken;
     this.scopes = scopes;
     this.expiresAt = expiresAt;
   }
+  /**
+   * Checks if this token has all the required scopes.
+   * @param scopes - Set of scopes to check for
+   * @returns True if the token has all required scopes, false otherwise
+   */
   hasAllScopes(scopes) {
     for (const scope of scopes) {
       if (!this.scopes.has(scope)) {
@@ -1429,6 +2100,14 @@ var OAuthToken = class {
   }
 };
 var OAuthTokenManager = class {
+  /**
+   * Gets a valid access token for the specified scopes.
+   * Returns a cached token if available and not expired, otherwise requests a new one.
+   * @param scopes - Set of OAuth scopes required for the token
+   * @param config - SDK configuration containing client credentials
+   * @returns A promise that resolves to a valid OAuth token
+   * @throws Error if client credentials are missing or token request fails
+   */
   async getToken(scopes, config) {
     var _a, _b, _c, _d, _e, _f;
     if (((_a = this.token) == null ? void 0 : _a.hasAllScopes(scopes)) && ((_b = this.token) == null ? void 0 : _b.expiresAt) && this.token.expiresAt - Date.now() > 5e3) {
@@ -1536,11 +2215,21 @@ import { z as z6 } from "zod";
 
 // src/http/errors/throwable-error.ts
 var ThrowableError = class extends Error {
+  /**
+   * Creates a new throwable error.
+   * @param message - The error message
+   * @param response - Optional response data associated with the error
+   */
   constructor(message, response) {
     super(message);
     this.message = message;
     this.response = response;
   }
+  /**
+   * Throws this error instance.
+   * Convenience method for explicitly throwing the error.
+   * @throws This error instance
+   */
   throw() {
     throw this;
   }
@@ -1593,8 +2282,8 @@ var Unauthorized = class extends ThrowableError {
 var DestinationsService = class extends BaseService {
   /**
    * List Destinations
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<ListDestinationsOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<ListDestinationsOkResponse>>} - Successful Response
    */
   async listDestinations(requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/destinations").setRequestSchema(z8.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -1628,6 +2317,7 @@ var packages = z9.lazy(() => {
     destination: z9.string(),
     destinationIso2: z9.string(),
     dataLimitInBytes: z9.number(),
+    dataLimitInGb: z9.number(),
     minDays: z9.number(),
     maxDays: z9.number(),
     priceInCents: z9.number()
@@ -1639,6 +2329,7 @@ var packagesResponse = z9.lazy(() => {
     destination: z9.string(),
     destinationISO2: z9.string(),
     dataLimitInBytes: z9.number(),
+    dataLimitInGB: z9.number(),
     minDays: z9.number(),
     maxDays: z9.number(),
     priceInCents: z9.number()
@@ -1647,6 +2338,7 @@ var packagesResponse = z9.lazy(() => {
     destination: data["destination"],
     destinationIso2: data["destinationISO2"],
     dataLimitInBytes: data["dataLimitInBytes"],
+    dataLimitInGb: data["dataLimitInGB"],
     minDays: data["minDays"],
     maxDays: data["maxDays"],
     priceInCents: data["priceInCents"]
@@ -1658,6 +2350,7 @@ var packagesRequest = z9.lazy(() => {
     destination: z9.string(),
     destinationIso2: z9.string(),
     dataLimitInBytes: z9.number(),
+    dataLimitInGb: z9.number(),
     minDays: z9.number(),
     maxDays: z9.number(),
     priceInCents: z9.number()
@@ -1666,6 +2359,7 @@ var packagesRequest = z9.lazy(() => {
     destination: data["destination"],
     destinationISO2: data["destinationIso2"],
     dataLimitInBytes: data["dataLimitInBytes"],
+    dataLimitInGB: data["dataLimitInGb"],
     minDays: data["minDays"],
     maxDays: data["maxDays"],
     priceInCents: data["priceInCents"]
@@ -1709,9 +2403,8 @@ var PackagesService = class extends BaseService {
    * @param {number} [params.limit] - Maximum number of packages to be returned in the response. The value must be greater than 0 and less than or equal to 160. If not provided, the default value is 20
    * @param {number} [params.startTime] - Epoch value representing the start time of the package's validity. This timestamp can be set to the current time or any time within the next 12 months
    * @param {number} [params.endTime] - Epoch value representing the end time of the package's validity. End time can be maximum 90 days after Start time
-   * @param {number} [params.duration] - Duration in seconds for the package's validity. If this parameter is present, it will override the startTime and endTime parameters. The maximum duration for a package's validity period is 90 days
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<ListPackagesOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<ListPackagesOkResponse>>} - Successful Response
    */
   async listPackages(params, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/packages").setRequestSchema(z11.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -1747,9 +2440,6 @@ var PackagesService = class extends BaseService {
     }).addQueryParam({
       key: "endTime",
       value: params == null ? void 0 : params.endTime
-    }).addQueryParam({
-      key: "duration",
-      value: params == null ? void 0 : params.duration
     }).build();
     return this.client.call(request);
   }
@@ -1764,8 +2454,9 @@ var createPurchaseV2Request = z12.lazy(() => {
   return z12.object({
     destination: z12.string(),
     dataLimitInGb: z12.number(),
-    startDate: z12.string(),
-    endDate: z12.string(),
+    startDate: z12.string().optional(),
+    endDate: z12.string().optional(),
+    duration: z12.number().optional(),
     quantity: z12.number().gte(1).lte(5),
     email: z12.string().optional(),
     referenceId: z12.string().optional(),
@@ -1777,8 +2468,9 @@ var createPurchaseV2RequestResponse = z12.lazy(() => {
   return z12.object({
     destination: z12.string(),
     dataLimitInGB: z12.number(),
-    startDate: z12.string(),
-    endDate: z12.string(),
+    startDate: z12.string().optional(),
+    endDate: z12.string().optional(),
+    duration: z12.number().optional(),
     quantity: z12.number().gte(1).lte(5),
     email: z12.string().optional(),
     referenceId: z12.string().optional(),
@@ -1789,6 +2481,7 @@ var createPurchaseV2RequestResponse = z12.lazy(() => {
     dataLimitInGb: data["dataLimitInGB"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     quantity: data["quantity"],
     email: data["email"],
     referenceId: data["referenceId"],
@@ -1800,8 +2493,9 @@ var createPurchaseV2RequestRequest = z12.lazy(() => {
   return z12.object({
     destination: z12.string(),
     dataLimitInGb: z12.number(),
-    startDate: z12.string(),
-    endDate: z12.string(),
+    startDate: z12.string().optional(),
+    endDate: z12.string().optional(),
+    duration: z12.number().optional(),
     quantity: z12.number().gte(1).lte(5),
     email: z12.string().optional(),
     referenceId: z12.string().optional(),
@@ -1812,6 +2506,7 @@ var createPurchaseV2RequestRequest = z12.lazy(() => {
     dataLimitInGB: data["dataLimitInGb"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     quantity: data["quantity"],
     email: data["email"],
     referenceId: data["referenceId"],
@@ -1861,29 +2556,39 @@ var createPurchaseV2OkResponseProfile = z14.lazy(() => {
   return z14.object({
     iccid: z14.string().min(18).max(22),
     activationCode: z14.string().min(1e3).max(8e3),
-    manualActivationCode: z14.string()
+    manualActivationCode: z14.string(),
+    iosActivationLink: z14.string(),
+    androidActivationLink: z14.string()
   });
 });
 var createPurchaseV2OkResponseProfileResponse = z14.lazy(() => {
   return z14.object({
     iccid: z14.string().min(18).max(22),
     activationCode: z14.string().min(1e3).max(8e3),
-    manualActivationCode: z14.string()
+    manualActivationCode: z14.string(),
+    iosActivationLink: z14.string(),
+    androidActivationLink: z14.string()
   }).transform((data) => ({
     iccid: data["iccid"],
     activationCode: data["activationCode"],
-    manualActivationCode: data["manualActivationCode"]
+    manualActivationCode: data["manualActivationCode"],
+    iosActivationLink: data["iosActivationLink"],
+    androidActivationLink: data["androidActivationLink"]
   }));
 });
 var createPurchaseV2OkResponseProfileRequest = z14.lazy(() => {
   return z14.object({
     iccid: z14.string().min(18).max(22),
     activationCode: z14.string().min(1e3).max(8e3),
-    manualActivationCode: z14.string()
+    manualActivationCode: z14.string(),
+    iosActivationLink: z14.string(),
+    androidActivationLink: z14.string()
   }).transform((data) => ({
     iccid: data["iccid"],
     activationCode: data["activationCode"],
-    manualActivationCode: data["manualActivationCode"]
+    manualActivationCode: data["manualActivationCode"],
+    iosActivationLink: data["iosActivationLink"],
+    androidActivationLink: data["androidActivationLink"]
   }));
 });
 
@@ -1925,6 +2630,7 @@ var package_ = z16.lazy(() => {
   return z16.object({
     id: z16.string(),
     dataLimitInBytes: z16.number(),
+    dataLimitInGb: z16.number(),
     destination: z16.string(),
     destinationIso2: z16.string(),
     destinationName: z16.string(),
@@ -1935,6 +2641,7 @@ var packageResponse = z16.lazy(() => {
   return z16.object({
     id: z16.string(),
     dataLimitInBytes: z16.number(),
+    dataLimitInGB: z16.number(),
     destination: z16.string(),
     destinationISO2: z16.string(),
     destinationName: z16.string(),
@@ -1942,6 +2649,7 @@ var packageResponse = z16.lazy(() => {
   }).transform((data) => ({
     id: data["id"],
     dataLimitInBytes: data["dataLimitInBytes"],
+    dataLimitInGb: data["dataLimitInGB"],
     destination: data["destination"],
     destinationIso2: data["destinationISO2"],
     destinationName: data["destinationName"],
@@ -1952,6 +2660,7 @@ var packageRequest = z16.lazy(() => {
   return z16.object({
     id: z16.string(),
     dataLimitInBytes: z16.number(),
+    dataLimitInGb: z16.number(),
     destination: z16.string(),
     destinationIso2: z16.string(),
     destinationName: z16.string(),
@@ -1959,6 +2668,7 @@ var packageRequest = z16.lazy(() => {
   }).transform((data) => ({
     id: data["id"],
     dataLimitInBytes: data["dataLimitInBytes"],
+    dataLimitInGB: data["dataLimitInGb"],
     destination: data["destination"],
     destinationISO2: data["destinationIso2"],
     destinationName: data["destinationName"],
@@ -1994,6 +2704,7 @@ var purchases = z18.lazy(() => {
     id: z18.string(),
     startDate: z18.string().nullable(),
     endDate: z18.string().nullable(),
+    duration: z18.number().optional().nullable(),
     createdDate: z18.string(),
     startTime: z18.number().optional().nullable(),
     endTime: z18.number().optional().nullable(),
@@ -2010,6 +2721,7 @@ var purchasesResponse = z18.lazy(() => {
     id: z18.string(),
     startDate: z18.string().nullable(),
     endDate: z18.string().nullable(),
+    duration: z18.number().optional().nullable(),
     createdDate: z18.string(),
     startTime: z18.number().optional().nullable(),
     endTime: z18.number().optional().nullable(),
@@ -2023,6 +2735,7 @@ var purchasesResponse = z18.lazy(() => {
     id: data["id"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     createdDate: data["createdDate"],
     startTime: data["startTime"],
     endTime: data["endTime"],
@@ -2039,6 +2752,7 @@ var purchasesRequest = z18.lazy(() => {
     id: z18.string(),
     startDate: z18.string().nullable(),
     endDate: z18.string().nullable(),
+    duration: z18.number().optional().nullable(),
     createdDate: z18.string(),
     startTime: z18.number().optional().nullable(),
     endTime: z18.number().optional().nullable(),
@@ -2052,6 +2766,7 @@ var purchasesRequest = z18.lazy(() => {
     id: data["id"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     createdDate: data["createdDate"],
     startTime: data["startTime"],
     endTime: data["endTime"],
@@ -2276,8 +2991,9 @@ var topUpEsimRequest = z24.lazy(() => {
   return z24.object({
     iccid: z24.string().min(18).max(22),
     dataLimitInGb: z24.number(),
-    startDate: z24.string(),
-    endDate: z24.string(),
+    startDate: z24.string().optional(),
+    endDate: z24.string().optional(),
+    duration: z24.number().optional(),
     email: z24.string().optional(),
     referenceId: z24.string().optional(),
     emailBrand: z24.string().optional(),
@@ -2289,8 +3005,9 @@ var topUpEsimRequestResponse = z24.lazy(() => {
   return z24.object({
     iccid: z24.string().min(18).max(22),
     dataLimitInGB: z24.number(),
-    startDate: z24.string(),
-    endDate: z24.string(),
+    startDate: z24.string().optional(),
+    endDate: z24.string().optional(),
+    duration: z24.number().optional(),
     email: z24.string().optional(),
     referenceId: z24.string().optional(),
     emailBrand: z24.string().optional(),
@@ -2301,6 +3018,7 @@ var topUpEsimRequestResponse = z24.lazy(() => {
     dataLimitInGb: data["dataLimitInGB"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     email: data["email"],
     referenceId: data["referenceId"],
     emailBrand: data["emailBrand"],
@@ -2312,8 +3030,9 @@ var topUpEsimRequestRequest = z24.lazy(() => {
   return z24.object({
     iccid: z24.string().min(18).max(22),
     dataLimitInGb: z24.number(),
-    startDate: z24.string(),
-    endDate: z24.string(),
+    startDate: z24.string().optional(),
+    endDate: z24.string().optional(),
+    duration: z24.number().optional(),
     email: z24.string().optional(),
     referenceId: z24.string().optional(),
     emailBrand: z24.string().optional(),
@@ -2324,6 +3043,7 @@ var topUpEsimRequestRequest = z24.lazy(() => {
     dataLimitInGB: data["dataLimitInGb"],
     startDate: data["startDate"],
     endDate: data["endDate"],
+    duration: data["duration"],
     email: data["email"],
     referenceId: data["referenceId"],
     emailBrand: data["emailBrand"],
@@ -2524,24 +3244,29 @@ import { z as z30 } from "zod";
 var getPurchaseConsumptionOkResponse = z30.lazy(() => {
   return z30.object({
     dataUsageRemainingInBytes: z30.number(),
+    dataUsageRemainingInGb: z30.number(),
     status: z30.string()
   });
 });
 var getPurchaseConsumptionOkResponseResponse = z30.lazy(() => {
   return z30.object({
     dataUsageRemainingInBytes: z30.number(),
+    dataUsageRemainingInGB: z30.number(),
     status: z30.string()
   }).transform((data) => ({
     dataUsageRemainingInBytes: data["dataUsageRemainingInBytes"],
+    dataUsageRemainingInGb: data["dataUsageRemainingInGB"],
     status: data["status"]
   }));
 });
 var getPurchaseConsumptionOkResponseRequest = z30.lazy(() => {
   return z30.object({
     dataUsageRemainingInBytes: z30.number(),
+    dataUsageRemainingInGb: z30.number(),
     status: z30.string()
   }).transform((data) => ({
     dataUsageRemainingInBytes: data["dataUsageRemainingInBytes"],
+    dataUsageRemainingInGB: data["dataUsageRemainingInGb"],
     status: data["status"]
   }));
 });
@@ -2550,8 +3275,8 @@ var getPurchaseConsumptionOkResponseRequest = z30.lazy(() => {
 var PurchasesService = class extends BaseService {
   /**
    * This endpoint is used to purchase a new eSIM by providing the package details.
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<CreatePurchaseV2OkResponse[]>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<CreatePurchaseV2OkResponse[]>>} - Successful Response
    */
   async createPurchaseV2(body, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/purchases/v2").setRequestSchema(createPurchaseV2RequestRequest).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2571,6 +3296,7 @@ var PurchasesService = class extends BaseService {
   }
   /**
    * This endpoint can be used to list all the successful purchases made between a given interval.
+   * @param {string} [params.purchaseId] - ID of the purchase
    * @param {string} [params.iccid] - ID of the eSIM
    * @param {string} [params.afterDate] - Start date of the interval for filtering purchases in the format 'yyyy-MM-dd'
    * @param {string} [params.beforeDate] - End date of the interval for filtering purchases in the format 'yyyy-MM-dd'
@@ -2580,9 +3306,8 @@ var PurchasesService = class extends BaseService {
    * @param {number} [params.limit] - Maximum number of purchases to be returned in the response. The value must be greater than 0 and less than or equal to 100. If not provided, the default value is 20
    * @param {number} [params.after] - Epoch value representing the start of the time interval for filtering purchases
    * @param {number} [params.before] - Epoch value representing the end of the time interval for filtering purchases
-   * @param {string} [params.purchaseId] - The id of a specific purchase.
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<ListPurchasesOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<ListPurchasesOkResponse>>} - Successful Response
    */
   async listPurchases(params, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/purchases").setRequestSchema(z31.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2598,6 +3323,9 @@ var PurchasesService = class extends BaseService {
       contentType: "json" /* Json */,
       status: 401
     }).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addQueryParam({
+      key: "purchaseId",
+      value: params == null ? void 0 : params.purchaseId
+    }).addQueryParam({
       key: "iccid",
       value: params == null ? void 0 : params.iccid
     }).addQueryParam({
@@ -2624,16 +3352,13 @@ var PurchasesService = class extends BaseService {
     }).addQueryParam({
       key: "before",
       value: params == null ? void 0 : params.before
-    }).addQueryParam({
-      key: "purchaseId",
-      value: params == null ? void 0 : params.purchaseId
     }).build();
     return this.client.call(request);
   }
   /**
    * This endpoint is used to purchase a new eSIM by providing the package details.
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<CreatePurchaseOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<CreatePurchaseOkResponse>>} - Successful Response
    */
   async createPurchase(body, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/purchases").setRequestSchema(createPurchaseRequestRequest).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2652,9 +3377,9 @@ var PurchasesService = class extends BaseService {
     return this.client.call(request);
   }
   /**
-   * This endpoint is used to top-up an existing eSIM with the previously associated destination by providing its ICCID and package details. To determine if an eSIM can be topped up, use the Get eSIM Status endpoint, which returns the `isTopUpAllowed` flag.
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<TopUpEsimOkResponse>>} Successful Response
+   * This endpoint is used to top-up an existing eSIM with the previously associated destination by providing its ICCID and package details. To determine if an eSIM can be topped up, use the Get eSIM endpoint, which returns the `isTopUpAllowed` flag.
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<TopUpEsimOkResponse>>} - Successful Response
    */
   async topUpEsim(body, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/purchases/topup").setRequestSchema(topUpEsimRequestRequest).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2681,8 +3406,8 @@ var PurchasesService = class extends BaseService {
   
   The end date can be extended or shortened as long as it adheres to the same pricing category and does not exceed the allowed duration limits.
   
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<EditPurchaseOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<EditPurchaseOkResponse>>} - Successful Response
    */
   async editPurchase(body, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/purchases/edit").setRequestSchema(editPurchaseRequestRequest).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2703,8 +3428,8 @@ var PurchasesService = class extends BaseService {
   /**
    * This endpoint can be called for consumption notifications (e.g. every 1 hour or when the user clicks a button). It returns the data balance (consumption) of purchased packages.
    * @param {string} purchaseId - ID of the purchase
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<GetPurchaseConsumptionOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetPurchaseConsumptionOkResponse>>} - Successful Response
    */
   async getPurchaseConsumption(purchaseId, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/purchases/{purchaseId}/consumption").setRequestSchema(z31.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2742,6 +3467,7 @@ var getEsimOkResponseEsim = z32.lazy(() => {
     activationCode: z32.string().min(1e3).max(8e3),
     manualActivationCode: z32.string(),
     status: z32.string(),
+    connectivityStatus: z32.string(),
     isTopUpAllowed: z32.boolean()
   });
 });
@@ -2752,6 +3478,7 @@ var getEsimOkResponseEsimResponse = z32.lazy(() => {
     activationCode: z32.string().min(1e3).max(8e3),
     manualActivationCode: z32.string(),
     status: z32.string(),
+    connectivityStatus: z32.string(),
     isTopUpAllowed: z32.boolean()
   }).transform((data) => ({
     iccid: data["iccid"],
@@ -2759,6 +3486,7 @@ var getEsimOkResponseEsimResponse = z32.lazy(() => {
     activationCode: data["activationCode"],
     manualActivationCode: data["manualActivationCode"],
     status: data["status"],
+    connectivityStatus: data["connectivityStatus"],
     isTopUpAllowed: data["isTopUpAllowed"]
   }));
 });
@@ -2769,6 +3497,7 @@ var getEsimOkResponseEsimRequest = z32.lazy(() => {
     activationCode: z32.string().min(1e3).max(8e3),
     manualActivationCode: z32.string(),
     status: z32.string(),
+    connectivityStatus: z32.string(),
     isTopUpAllowed: z32.boolean()
   }).transform((data) => ({
     iccid: data["iccid"],
@@ -2776,6 +3505,7 @@ var getEsimOkResponseEsimRequest = z32.lazy(() => {
     activationCode: data["activationCode"],
     manualActivationCode: data["manualActivationCode"],
     status: data["status"],
+    connectivityStatus: data["connectivityStatus"],
     isTopUpAllowed: data["isTopUpAllowed"]
   }));
 });
@@ -2951,9 +3681,9 @@ var getEsimHistoryOkResponseRequest = z38.lazy(() => {
 var ESimService = class extends BaseService {
   /**
    * Get eSIM
-   * @param {string} iccid - ID of the eSIM
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<GetEsimOkResponse>>} Successful Response
+   * @param {string} params.iccid - ID of the eSIM
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetEsimOkResponse>>} - Successful Response
    */
   async getEsim(params, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/esim").setRequestSchema(z39.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -2977,8 +3707,8 @@ var ESimService = class extends BaseService {
   /**
    * Get eSIM Device
    * @param {string} iccid - ID of the eSIM
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<GetEsimDeviceOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetEsimDeviceOkResponse>>} - Successful Response
    */
   async getEsimDevice(iccid, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/esim/{iccid}/device").setRequestSchema(z39.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -3002,8 +3732,8 @@ var ESimService = class extends BaseService {
   /**
    * Get eSIM History
    * @param {string} iccid - ID of the eSIM
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<GetEsimHistoryOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<GetEsimHistoryOkResponse>>} - Successful Response
    */
   async getEsimHistory(iccid, requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("GET").setPath("/esim/{iccid}/history").setRequestSchema(z39.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({
@@ -3055,8 +3785,8 @@ var tokenOkResponseRequest = z40.lazy(() => {
 var IFrameService = class extends BaseService {
   /**
    * Generate a new token to be used in the iFrame
-   * @param {RequestConfig} requestConfig - (Optional) The request configuration for retry and validation.
-   * @returns {Promise<HttpResponse<TokenOkResponse>>} Successful Response
+   * @param {RequestConfig} [requestConfig] - The request configuration for retry and validation.
+   * @returns {Promise<HttpResponse<TokenOkResponse>>} - Successful Response
    */
   async token(requestConfig) {
     const request = new RequestBuilder().setBaseUrl((requestConfig == null ? void 0 : requestConfig.baseUrl) || this.config.baseUrl || this.config.environment || "https://api.celitech.net/v1" /* DEFAULT */).setConfig(this.config).setMethod("POST").setPath("/iframe/token").setRequestSchema(z41.any()).setScopes([]).setTokenManager(this.tokenManager).setRequestContentType("json" /* Json */).addResponse({