celitech-sdk 1.3.61 → 1.3.63

package/dist/index.d.ts

@@ -1,81 +1,221 @@
 import { ZodType, z } from 'zod';
 
+/**
+ * Available API environments with their base URLs.
+ * Use these constants to configure the SDK for different environments (production, staging, etc.).
+ */
 declare enum Environment {
+    /** DEFAULT environment base URL */
     DEFAULT = "https://api.celitech.net/v1"
 }
 
+/**
+ * Standard HTTP methods supported by the SDK.
+ */
 type HttpMethod$1 = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+/**
+ * Represents an HTTP request with all its components.
+ */
 interface HttpRequest {
+    /** Base URL of the API endpoint */
     baseUrl: string;
+    /** HTTP method for the request */
     method: HttpMethod$1;
+    /** Request path (relative to base URL) */
     path: string;
+    /** Request headers as key-value pairs */
     headers: Map<string, unknown>;
+    /** Request body payload (optional) */
     body?: BodyInit;
+    /** Signal to abort the request (optional) */
     abortSignal?: AbortSignal;
+    /** Query string parameters */
     queryParams: Map<string, unknown>;
+    /** Path parameters for URL templating */
     pathParams: Map<string, unknown>;
 }
+/**
+ * Metadata about an HTTP response.
+ */
 interface HttpMetadata$1 {
+    /** HTTP status code */
     status: number;
+    /** HTTP status text message */
     statusText: string;
+    /** Response headers as key-value pairs */
     headers: Record<string, string>;
 }
+/**
+ * Represents an HTTP response with typed data.
+ * @template T - The type of the response data
+ */
 interface HttpResponse$1<T> {
+    /** Parsed response data (optional) */
     data?: T;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata$1;
+    /** Raw response object from the HTTP client */
     raw: ArrayBuffer;
 }
+/**
+ * Represents an HTTP error response.
+ */
 interface HttpError$1 {
+    /** Error message or description */
     error: string;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata$1;
 }
+/**
+ * Hook interface for intercepting and modifying HTTP requests and responses.
+ * Allows custom logic to be executed at different stages of the request lifecycle.
+ */
 interface Hook {
+    /**
+     * Called before an HTTP request is sent.
+     * Allows modification of the request before execution.
+     * @param request - The HTTP request to be sent
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the potentially modified request
+     */
     beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest>;
+    /**
+     * Called after a successful HTTP response is received.
+     * Allows processing or modification of the response.
+     * @param request - The original HTTP request
+     * @param response - The HTTP response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to the potentially modified response
+     */
     afterResponse(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpResponse$1<any>>;
+    /**
+     * Called when an HTTP request results in an error.
+     * Allows custom error handling and transformation.
+     * @param request - The original HTTP request
+     * @param response - The error response received
+     * @param params - Additional custom parameters
+     * @returns A promise that resolves to an error object
+     */
     onError(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpError$1>;
 }
 
+/**
+ * OpenAPI parameter serialization styles.
+ * Defines how parameters should be formatted in the request.
+ */
 declare enum SerializationStyle {
+    /** Simple comma-separated values (e.g., "3,4,5") */
     SIMPLE = "simple",
+    /** Label prefix with dot notation (e.g., ".3.4.5") */
     LABEL = "label",
+    /** Matrix semicolon-prefixed (e.g., ";id=3;id=4") */
     MATRIX = "matrix",
+    /** Form-style ampersand-separated (e.g., "id=3&id=4") */
     FORM = "form",
+    /** Space-delimited values (e.g., "id=3 4 5") */
     SPACE_DELIMITED = "space_delimited",
+    /** Pipe-delimited values (e.g., "id=3|4|5") */
     PIPE_DELIMITED = "pipe_delimited",
+    /** Deep object notation (e.g., "id[role]=admin") */
     DEEP_OBJECT = "deep_object",
+    /** No specific style applied */
     NONE = "none"
 }
 
+/**
+ * Represents an OAuth 2.0 access token with its associated metadata.
+ * Stores the token, granted scopes, and expiration time.
+ */
 declare class OAuthToken {
     accessToken: string;
     scopes: Set<string>;
     expiresAt: number | null;
+    /**
+     * 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: string, scopes: Set<string>, expiresAt: number | null);
+    /**
+     * 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: Set<string>): boolean;
 }
+/**
+ * Manages OAuth 2.0 access tokens for the SDK.
+ * Handles token retrieval, caching, and automatic refresh when tokens expire.
+ * Implements a singleton pattern to share tokens across the SDK.
+ */
 declare class OAuthTokenManager {
+    /** Singleton instance of the token manager */
     private static instance;
+    /** Currently cached OAuth token */
     private token?;
+    /**
+     * 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
+     */
     getToken(scopes: Set<string>, config: SdkConfig): Promise<OAuthToken>;
 }
 
+/**
+ * Error class that can be thrown explicitly via a throw() method.
+ * Extends the built-in Error class with a convenience method for throwing.
+ */
 declare class ThrowableError extends Error {
     message: string;
     protected response?: unknown;
+    /**
+     * Creates a new throwable error.
+     * @param message - The error message
+     * @param response - Optional response data associated with the error
+     */
     constructor(message: string, response?: unknown);
+    /**
+     * Throws this error instance.
+     * Convenience method for explicitly throwing the error.
+     * @throws This error instance
+     */
     throw(): void;
 }
 
+/**
+ * Defines an expected response format with schema validation.
+ * Used to match and validate responses based on content type and status code.
+ */
 interface ResponseDefinition {
+    /** Zod schema for validating the response body */
     schema: ZodType;
+    /** The content type of this response (e.g., 'application/json') */
     contentType: ContentType;
+    /** The HTTP status code this definition applies to */
     status: number;
 }
+/**
+ * Defines an error response format with custom error class.
+ * Used to throw typed errors based on content type and status code.
+ */
 interface ErrorDefinition {
+    /** Constructor for the error class to instantiate */
     error: new (...args: any[]) => ThrowableError;
+    /** The content type of this error response */
     contentType: ContentType;
+    /** The HTTP status code this error applies to */
     status: number;
 }
+/**
+ * Parameters required to create a Request instance.
+ * Contains all configuration needed for HTTP execution, validation, and error handling.
+ *
+ * @template Page - The type of paginated data items
+ */
 interface CreateRequestParameters<Page = unknown[]> {
     baseUrl: string;
     method: HttpMethod;
@@ -83,6 +223,7 @@ interface CreateRequestParameters<Page = unknown[]> {
     headers: Map<string, RequestParameter>;
     queryParams: Map<string, RequestParameter>;
     pathParams: Map<string, RequestParameter>;
+    cookies: Map<string, RequestParameter>;
     path: string;
     config: SdkConfig;
     responses: ResponseDefinition[];
@@ -97,33 +238,72 @@ interface CreateRequestParameters<Page = unknown[]> {
     scopes?: Set<string>;
     tokenManager: OAuthTokenManager;
 }
+/**
+ * Represents a request parameter with serialization metadata.
+ * Wraps a value with OpenAPI serialization instructions for proper encoding.
+ */
 interface RequestParameter {
+    /** The parameter name (may be undefined for path substitution) */
     key: string | undefined;
+    /** The actual parameter value */
     value: unknown;
+    /** Whether to explode arrays/objects into multiple parameters */
     explode: boolean;
+    /** Whether to URL-encode the value */
     encode: boolean;
+    /** The OpenAPI serialization style (e.g., SIMPLE, FORM, MATRIX) */
     style: SerializationStyle;
+    /** Whether this parameter is a pagination limit */
     isLimit: boolean;
+    /** Whether this parameter is a pagination offset */
     isOffset: boolean;
+    /** Whether this parameter is a pagination cursor */
     isCursor: boolean;
 }
+/**
+ * Configuration for limit-offset pagination.
+ * Used for traditional page-based pagination with size and offset.
+ *
+ * @template Page - The type of page data
+ */
 interface RequestPagination<Page> {
+    /** The number of items per page */
     pageSize?: number;
+    /** JSON path to extract page data from response */
     pagePath: string[];
+    /** Zod schema for validating page data */
     pageSchema?: ZodType<Page, any, any>;
 }
+/**
+ * Configuration for cursor-based pagination.
+ * Used for stateless pagination with cursor tokens.
+ *
+ * @template Page - The type of page data
+ */
 interface RequestCursorPagination<Page> {
+    /** JSON path to extract page data from response */
     pagePath: string[];
+    /** Zod schema for validating page data */
     pageSchema?: ZodType<Page, any, any>;
+    /** JSON path to extract next cursor from response */
     cursorPath: string[];
+    /** Zod schema for validating cursor value */
     cursorSchema?: ZodType<string | null | undefined>;
 }
 
+/**
+ * Represents an HTTP request with all necessary configuration and parameters.
+ * Handles path/query/header/cookie serialization, pagination, validation, and retry logic.
+ * This is the core request object passed through the handler chain for execution.
+ *
+ * @template PageSchema - The type of paginated data returned by this request
+ */
 declare class Request<PageSchema = unknown[]> {
     baseUrl: string;
     headers: Map<string, RequestParameter>;
     queryParams: Map<string, RequestParameter>;
     pathParams: Map<string, RequestParameter>;
+    cookies: Map<string, RequestParameter>;
     body?: any;
     method: HttpMethod;
     path: string;
@@ -141,14 +321,73 @@ declare class Request<PageSchema = unknown[]> {
     tokenManager: OAuthTokenManager;
     private readonly pathPattern;
     constructor(params: CreateRequestParameters<PageSchema>);
+    /**
+     * 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: string, param: RequestParameter): void;
+    /**
+     * 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: string, param: RequestParameter): void;
+    /**
+     * 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: string, param: RequestParameter): void;
+    /**
+     * Sets the request body if the value is defined.
+     *
+     * @param body - The request body to send
+     */
     addBody(body: any): void;
+    /**
+     * 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: HttpRequest): void;
+    /**
+     * 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(): string;
+    /**
+     * 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?: Partial<CreateRequestParameters>): Request<unknown[]>;
+    /**
+     * Serializes headers to a format suitable for HTTP execution.
+     *
+     * @returns Serialized headers as HeadersInit, or undefined if no headers
+     */
     getHeaders(): HeadersInit | undefined;
+    /**
+     * Serializes cookies to a format suitable for HTTP execution.
+     *
+     * @returns Serialized cookies as a record, or undefined if no cookies
+     */
+    getCookies(): Record<string, string> | undefined;
+    /**
+     * 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?: string): void;
     private constructPath;
     private getOffsetParam;
@@ -156,7 +395,14 @@ declare class Request<PageSchema = unknown[]> {
     private getAllParams;
 }
 
+/**
+ * Standard HTTP methods supported by the SDK.
+ */
 type HttpMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+/**
+ * SDK configuration interface.
+ * Contains all settings required to initialize and configure the SDK.
+ */
 interface BaseConfig {
     retry?: RetryOptions;
     validation?: ValidationOptions;
@@ -176,32 +422,72 @@ interface TokenAuthConfig extends BaseConfig {
     accessToken: string;
 }
 type SdkConfig = ClientCredentialAuthConfig | TokenAuthConfig;
+/**
+ * Metadata about an HTTP response.
+ * Contains status information and headers from the server response.
+ */
 interface HttpMetadata {
+    /** HTTP status code (e.g., 200, 404, 500) */
     status: number;
+    /** HTTP status text message (e.g., "OK", "Not Found") */
     statusText: string;
+    /** Response headers as key-value pairs */
     headers: Record<string, string>;
 }
+/**
+ * Standard HTTP response with typed data.
+ * @template T - The type of the response data
+ */
 interface HttpResponse<T = unknown> {
+    /** Parsed response data (optional) */
     data?: T;
+    /** Response metadata (status, headers, etc.) */
     metadata: HttpMetadata;
+    /** Raw response object from the HTTP client */
     raw: ArrayBuffer;
 }
+/**
+ * HTTP response for paginated API endpoints.
+ * Marker interface extending HttpResponse for type safety with pagination.
+ * @template T - The type of a single page of data
+ */
 interface PaginatedHttpResponse<T = unknown> extends HttpResponse<T> {
 }
+/**
+ * HTTP response for cursor-paginated API endpoints.
+ * Includes a cursor for fetching the next page of results.
+ * @template T - The type of a single page of data
+ */
 interface CursorPaginatedHttpResponse<T = unknown> extends HttpResponse<T> {
+    /** Cursor string for fetching the next page, null if no more pages, undefined if not applicable */
     nextCursor?: string | null;
 }
+/**
+ * Supported content types for HTTP requests and responses.
+ * Determines how the SDK serializes requests and parses responses.
+ */
 declare enum ContentType {
+    /** JSON format (application/json) */
     Json = "json",
+    /** XML format (application/xml, text/xml) */
     Xml = "xml",
+    /** PDF document (application/pdf) */
     Pdf = "pdf",
+    /** Image file (image/*) */
     Image = "image",
+    /** Generic file */
     File = "file",
+    /** Binary data (application/octet-stream) */
     Binary = "binary",
+    /** URL-encoded form data (application/x-www-form-urlencoded) */
     FormUrlEncoded = "form",
+    /** Plain text (text/plain) */
     Text = "text",
+    /** Multipart form data for file uploads (multipart/form-data) */
     MultipartFormData = "multipartFormData",
+    /** Server-sent events stream (text/event-stream) */
     EventStream = "eventStream",
+    /** No content (HTTP 204) */
     NoContent = "noContent"
 }
 interface RequestConfig {
@@ -217,36 +503,144 @@ interface ValidationOptions {
     responseValidation?: boolean;
 }
 
+/**
+ * Error class for HTTP request failures.
+ * Captures error details including status, metadata, and the raw response.
+ */
 declare class HttpError extends Error {
+    /** Error message or status text */
     readonly error: string;
+    /** HTTP response metadata (status, headers, etc.) */
     readonly metadata: HttpMetadata;
+    /** Raw response object from the HTTP client */
     readonly raw?: ArrayBuffer;
+    /**
+     * 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: HttpMetadata, raw?: ArrayBuffer, error?: string);
 }
 
+/**
+ * Default implementation of the Hook interface that provides pass-through behavior.
+ * This hook can be extended to add custom logic for request/response interception.
+ */
 declare class CustomHook implements Hook {
+    /**
+     * 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
+     */
     beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest>;
+    /**
+     * 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
+     */
     afterResponse(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpResponse$1<any>>;
+    /**
+     * 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
+     */
     onError(request: HttpRequest, response: HttpResponse$1<any>, params: Map<string, string>): Promise<HttpError>;
 }
 
+/**
+ * Core HTTP client for making API requests.
+ * Manages request/response handling through a chain of handlers for validation, retry, hooks, and more.
+ */
 declare class HttpClient {
     private config;
+    /** Chain of request handlers that process requests in sequence */
     private readonly requestHandlerChain;
+    /**
+     * 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: SdkConfig, hook?: CustomHook);
+    /**
+     * 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<T>(request: Request): Promise<HttpResponse<T>>;
+    /**
+     * 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
+     */
     stream<T>(request: Request): AsyncGenerator<HttpResponse<T>>;
+    /**
+     * 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
+     */
     callPaginated<FullResponse, Page>(request: Request<Page>): Promise<PaginatedHttpResponse<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
+     */
     callCursorPaginated<FullResponse, Page>(request: Request<Page>): Promise<CursorPaginatedHttpResponse<Page>>;
+    /**
+     * Updates the base URL for all subsequent requests.
+     * @param url - The new base URL to use
+     */
     setBaseUrl(url: string): void;
+    /**
+     * Updates the SDK configuration.
+     * @param config - The new SDK configuration
+     */
     setConfig(config: SdkConfig): void;
+    /**
+     * 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
+     */
     private getPage;
+    /**
+     * 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
+     */
     private getNextCursor;
 }
 
+/**
+ * Base service class that all API service classes extend.
+ * Provides common functionality including HTTP client management and configuration.
+ */
 declare class BaseService {
     config: SdkConfig;
     protected tokenManager: OAuthTokenManager;
+    /** The HTTP client instance used to make API requests */
     client: HttpClient;
     constructor(config: SdkConfig, tokenManager: OAuthTokenManager);
     set baseUrl(baseUrl: string);
@@ -259,7 +653,9 @@ declare class BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListDestinationsOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listDestinationsOkResponse: z.ZodLazy<z.ZodObject<{
     destinations: z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -300,6 +696,11 @@ declare const listDestinationsOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type ListDestinationsOkResponse = z.infer<typeof listDestinationsOkResponse>;
 
+/**
+ * Service class for DestinationsService operations.
+ * Provides methods to interact with DestinationsService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class DestinationsService extends BaseService {
     /**
      * List Destinations
@@ -310,7 +711,9 @@ declare class DestinationsService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Destinations model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const destinations: z.ZodLazy<z.ZodObject<{
     name: z.ZodString;
@@ -339,7 +742,9 @@ declare const destinations: z.ZodLazy<z.ZodObject<{
 type Destinations = z.infer<typeof destinations>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListPackagesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
     packages: z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -347,6 +752,7 @@ declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
         destination: z.ZodString;
         destinationIso2: z.ZodString;
         dataLimitInBytes: z.ZodNumber;
+        dataLimitInGb: z.ZodNumber;
         minDays: z.ZodNumber;
         maxDays: z.ZodNumber;
         priceInCents: z.ZodNumber;
@@ -355,6 +761,7 @@ declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         minDays: number;
         maxDays: number;
         priceInCents: number;
@@ -363,6 +770,7 @@ declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         minDays: number;
         maxDays: number;
         priceInCents: number;
@@ -374,6 +782,7 @@ declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         minDays: number;
         maxDays: number;
         priceInCents: number;
@@ -385,6 +794,7 @@ declare const listPackagesOkResponse: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         minDays: number;
         maxDays: number;
         priceInCents: number;
@@ -409,6 +819,11 @@ interface ListPackagesParams {
     endTime?: number;
 }
 
+/**
+ * Service class for PackagesService operations.
+ * Provides methods to interact with PackagesService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class PackagesService extends BaseService {
     /**
      * List Packages
@@ -426,13 +841,16 @@ declare class PackagesService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Packages model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const packages: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
     destination: z.ZodString;
     destinationIso2: z.ZodString;
     dataLimitInBytes: z.ZodNumber;
+    dataLimitInGb: z.ZodNumber;
     minDays: z.ZodNumber;
     maxDays: z.ZodNumber;
     priceInCents: z.ZodNumber;
@@ -441,6 +859,7 @@ declare const packages: z.ZodLazy<z.ZodObject<{
     destinationIso2: string;
     id: string;
     dataLimitInBytes: number;
+    dataLimitInGb: number;
     minDays: number;
     maxDays: number;
     priceInCents: number;
@@ -449,6 +868,7 @@ declare const packages: z.ZodLazy<z.ZodObject<{
     destinationIso2: string;
     id: string;
     dataLimitInBytes: number;
+    dataLimitInGb: number;
     minDays: number;
     maxDays: number;
     priceInCents: number;
@@ -460,6 +880,7 @@ declare const packages: z.ZodLazy<z.ZodObject<{
  * @property {string} - ISO3 representation of the package's destination.
  * @property {string} - ISO2 representation of the package's destination.
  * @property {number} - Size of the package in Bytes
+ * @property {number} - Size of the package in GB
  * @property {number} - Min number of days for the package
  * @property {number} - Max number of days for the package
  * @property {number} - Price of the package in cents
@@ -467,7 +888,9 @@ declare const packages: z.ZodLazy<z.ZodObject<{
 type Packages = z.infer<typeof packages>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseV2Request model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseV2Request: z.ZodLazy<z.ZodObject<{
     destination: z.ZodString;
@@ -507,20 +930,22 @@ declare const createPurchaseV2Request: z.ZodLazy<z.ZodObject<{
  *
  * @typedef  {CreatePurchaseV2Request} createPurchaseV2Request
  * @property {string} - ISO representation of the package's destination. Supports both ISO2 (e.g., 'FR') and ISO3 (e.g., 'FRA') country codes.
- * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20GB
+ * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20, 50GB
  * @property {string} - Start date of the package's validity in the format 'yyyy-MM-dd'. This date can be set to the current day or any day within the next 12 months.
  * @property {string} - End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 90 days after Start date.
  * @property {number} - Duration of the package in days. Available values are 1, 2, 7, 14, 30, or 90. Either provide startDate/endDate or duration.
  * @property {number} - Number of eSIMs to purchase.
  * @property {string} - Email address where the purchase confirmation email will be sent (including QR Code & activation steps)
  * @property {string} - An identifier provided by the partner to link this purchase to their booking or transaction for analytics and debugging purposes.
- * @property {string} - Customize the network brand of the issued eSIM. The `networkBrand` parameter cannot exceed 15 characters in length and must contain only letters and numbers. This feature is available to platforms with Diamond tier only.
+ * @property {string} - Customize the network brand of the issued eSIM. The `networkBrand` parameter cannot exceed 15 characters in length and must contain only letters, numbers, dots (.), ampersands (&), and spaces. This feature is available to platforms with Diamond tier only.
  * @property {string} - Customize the email subject brand. The `emailBrand` parameter cannot exceed 25 characters in length and must contain only letters, numbers, and spaces. This feature is available to platforms with Diamond tier only.
  */
 type CreatePurchaseV2Request = z.infer<typeof createPurchaseV2Request>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseV2OkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseV2OkResponse: z.ZodLazy<z.ZodObject<{
     purchase: z.ZodLazy<z.ZodObject<{
@@ -540,14 +965,20 @@ declare const createPurchaseV2OkResponse: z.ZodLazy<z.ZodObject<{
         iccid: z.ZodString;
         activationCode: z.ZodString;
         manualActivationCode: z.ZodString;
+        iosActivationLink: z.ZodString;
+        androidActivationLink: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         iccid: string;
         activationCode: string;
         manualActivationCode: string;
+        iosActivationLink: string;
+        androidActivationLink: string;
     }, {
         iccid: string;
         activationCode: string;
         manualActivationCode: string;
+        iosActivationLink: string;
+        androidActivationLink: string;
     }>>;
 }, "strip", z.ZodTypeAny, {
     purchase: {
@@ -559,6 +990,8 @@ declare const createPurchaseV2OkResponse: z.ZodLazy<z.ZodObject<{
         iccid: string;
         activationCode: string;
         manualActivationCode: string;
+        iosActivationLink: string;
+        androidActivationLink: string;
     };
 }, {
     purchase: {
@@ -570,6 +1003,8 @@ declare const createPurchaseV2OkResponse: z.ZodLazy<z.ZodObject<{
         iccid: string;
         activationCode: string;
         manualActivationCode: string;
+        iosActivationLink: string;
+        androidActivationLink: string;
     };
 }>>;
 /**
@@ -581,7 +1016,9 @@ declare const createPurchaseV2OkResponse: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseV2OkResponse = z.infer<typeof createPurchaseV2OkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the ListPurchasesOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
     purchases: z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -596,6 +1033,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
         package: z.ZodLazy<z.ZodObject<{
             id: z.ZodString;
             dataLimitInBytes: z.ZodNumber;
+            dataLimitInGb: z.ZodNumber;
             destination: z.ZodString;
             destinationIso2: z.ZodString;
             destinationName: z.ZodString;
@@ -605,6 +1043,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         }, {
@@ -612,6 +1051,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         }>>;
@@ -635,6 +1075,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         };
@@ -658,6 +1099,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         };
@@ -685,6 +1127,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         };
@@ -711,6 +1154,7 @@ declare const listPurchasesOkResponse: z.ZodLazy<z.ZodObject<{
             destinationIso2: string;
             id: string;
             dataLimitInBytes: number;
+            dataLimitInGb: number;
             priceInCents: number;
             destinationName: string;
         };
@@ -748,7 +1192,9 @@ interface ListPurchasesParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseRequest: z.ZodLazy<z.ZodObject<{
     destination: z.ZodString;
@@ -763,9 +1209,9 @@ declare const createPurchaseRequest: z.ZodLazy<z.ZodObject<{
     endTime: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     destination: string;
+    dataLimitInGb: number;
     startDate: string;
     endDate: string;
-    dataLimitInGb: number;
     email?: string | undefined;
     referenceId?: string | undefined;
     networkBrand?: string | undefined;
@@ -774,9 +1220,9 @@ declare const createPurchaseRequest: z.ZodLazy<z.ZodObject<{
     endTime?: number | undefined;
 }, {
     destination: string;
+    dataLimitInGb: number;
     startDate: string;
     endDate: string;
-    dataLimitInGb: number;
     email?: string | undefined;
     referenceId?: string | undefined;
     networkBrand?: string | undefined;
@@ -788,12 +1234,12 @@ declare const createPurchaseRequest: z.ZodLazy<z.ZodObject<{
  *
  * @typedef  {CreatePurchaseRequest} createPurchaseRequest
  * @property {string} - ISO representation of the package's destination. Supports both ISO2 (e.g., 'FR') and ISO3 (e.g., 'FRA') country codes.
- * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20GB
+ * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20, 50GB
  * @property {string} - Start date of the package's validity in the format 'yyyy-MM-dd'. This date can be set to the current day or any day within the next 12 months.
  * @property {string} - End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 90 days after Start date.
  * @property {string} - Email address where the purchase confirmation email will be sent (including QR Code & activation steps)
  * @property {string} - An identifier provided by the partner to link this purchase to their booking or transaction for analytics and debugging purposes.
- * @property {string} - Customize the network brand of the issued eSIM. The `networkBrand` parameter cannot exceed 15 characters in length and must contain only letters and numbers. This feature is available to platforms with Diamond tier only.
+ * @property {string} - Customize the network brand of the issued eSIM. The `networkBrand` parameter cannot exceed 15 characters in length and must contain only letters, numbers, dots (.), ampersands (&), and spaces. This feature is available to platforms with Diamond tier only.
  * @property {string} - Customize the email subject brand. The `emailBrand` parameter cannot exceed 25 characters in length and must contain only letters, numbers, and spaces. This feature is available to platforms with Diamond tier only.
  * @property {number} - 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.
  * @property {number} - Epoch value representing the end time of the package's validity. End time can be maximum 90 days after Start time.
@@ -801,7 +1247,9 @@ declare const createPurchaseRequest: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseRequest = z.infer<typeof createPurchaseRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseOkResponse: z.ZodLazy<z.ZodObject<{
     purchase: z.ZodLazy<z.ZodObject<{
@@ -882,7 +1330,9 @@ declare const createPurchaseOkResponse: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseOkResponse = z.infer<typeof createPurchaseOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TopUpEsimRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const topUpEsimRequest: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -922,7 +1372,7 @@ declare const topUpEsimRequest: z.ZodLazy<z.ZodObject<{
  *
  * @typedef  {TopUpEsimRequest} topUpEsimRequest
  * @property {string} - ID of the eSIM
- * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20GB
+ * @property {number} - Size of the package in GB. The available options are 0.5, 1, 2, 3, 5, 8, 20, 50GB
  * @property {string} - Start date of the package's validity in the format 'yyyy-MM-dd'. This date can be set to the current day or any day within the next 12 months.
  * @property {string} - End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 90 days after Start date.
  * @property {number} - Duration of the package in days. Available values are 1, 2, 7, 14, 30, or 90. Either provide startDate/endDate or duration.
@@ -935,7 +1385,9 @@ declare const topUpEsimRequest: z.ZodLazy<z.ZodObject<{
 type TopUpEsimRequest = z.infer<typeof topUpEsimRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TopUpEsimOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const topUpEsimOkResponse: z.ZodLazy<z.ZodObject<{
     purchase: z.ZodLazy<z.ZodObject<{
@@ -1006,7 +1458,9 @@ declare const topUpEsimOkResponse: z.ZodLazy<z.ZodObject<{
 type TopUpEsimOkResponse = z.infer<typeof topUpEsimOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the EditPurchaseRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const editPurchaseRequest: z.ZodLazy<z.ZodObject<{
     purchaseId: z.ZodString;
@@ -1039,7 +1493,9 @@ declare const editPurchaseRequest: z.ZodLazy<z.ZodObject<{
 type EditPurchaseRequest = z.infer<typeof editPurchaseRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the EditPurchaseOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const editPurchaseOkResponse: z.ZodLazy<z.ZodObject<{
     purchaseId: z.ZodString;
@@ -1072,26 +1528,37 @@ declare const editPurchaseOkResponse: z.ZodLazy<z.ZodObject<{
 type EditPurchaseOkResponse = z.infer<typeof editPurchaseOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetPurchaseConsumptionOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getPurchaseConsumptionOkResponse: z.ZodLazy<z.ZodObject<{
     dataUsageRemainingInBytes: z.ZodNumber;
+    dataUsageRemainingInGb: z.ZodNumber;
     status: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     status: string;
     dataUsageRemainingInBytes: number;
+    dataUsageRemainingInGb: number;
 }, {
     status: string;
     dataUsageRemainingInBytes: number;
+    dataUsageRemainingInGb: number;
 }>>;
 /**
  *
  * @typedef  {GetPurchaseConsumptionOkResponse} getPurchaseConsumptionOkResponse
  * @property {number} - Remaining balance of the package in bytes
+ * @property {number} - Remaining balance of the package in GB
  * @property {string} - Status of the connectivity, possible values are 'ACTIVE' or 'NOT_ACTIVE'
  */
 type GetPurchaseConsumptionOkResponse = z.infer<typeof getPurchaseConsumptionOkResponse>;
 
+/**
+ * Service class for PurchasesService operations.
+ * Provides methods to interact with PurchasesService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class PurchasesService extends BaseService {
     /**
      * This endpoint is used to purchase a new eSIM by providing the package details.
@@ -1150,7 +1617,9 @@ declare class PurchasesService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseV2OkResponsePurchase model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseV2OkResponsePurchase: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -1175,20 +1644,28 @@ declare const createPurchaseV2OkResponsePurchase: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseV2OkResponsePurchase = z.infer<typeof createPurchaseV2OkResponsePurchase>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseV2OkResponseProfile model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseV2OkResponseProfile: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
     activationCode: z.ZodString;
     manualActivationCode: z.ZodString;
+    iosActivationLink: z.ZodString;
+    androidActivationLink: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     iccid: string;
     activationCode: string;
     manualActivationCode: string;
+    iosActivationLink: string;
+    androidActivationLink: string;
 }, {
     iccid: string;
     activationCode: string;
     manualActivationCode: string;
+    iosActivationLink: string;
+    androidActivationLink: string;
 }>>;
 /**
  *
@@ -1196,11 +1673,15 @@ declare const createPurchaseV2OkResponseProfile: z.ZodLazy<z.ZodObject<{
  * @property {string} - ID of the eSIM
  * @property {string} - QR Code of the eSIM as base64
  * @property {string} - Manual Activation Code of the eSIM
+ * @property {string} - iOS Activation Link of the eSIM
+ * @property {string} - Android Activation Link of the eSIM
  */
 type CreatePurchaseV2OkResponseProfile = z.infer<typeof createPurchaseV2OkResponseProfile>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Purchases model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const purchases: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -1214,6 +1695,7 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
     package: z.ZodLazy<z.ZodObject<{
         id: z.ZodString;
         dataLimitInBytes: z.ZodNumber;
+        dataLimitInGb: z.ZodNumber;
         destination: z.ZodString;
         destinationIso2: z.ZodString;
         destinationName: z.ZodString;
@@ -1223,6 +1705,7 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         priceInCents: number;
         destinationName: string;
     }, {
@@ -1230,6 +1713,7 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         priceInCents: number;
         destinationName: string;
     }>>;
@@ -1253,6 +1737,7 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         priceInCents: number;
         destinationName: string;
     };
@@ -1276,6 +1761,7 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
         destinationIso2: string;
         id: string;
         dataLimitInBytes: number;
+        dataLimitInGb: number;
         priceInCents: number;
         destinationName: string;
     };
@@ -1310,11 +1796,14 @@ declare const purchases: z.ZodLazy<z.ZodObject<{
 type Purchases = z.infer<typeof purchases>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Package_ model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const package_: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
     dataLimitInBytes: z.ZodNumber;
+    dataLimitInGb: z.ZodNumber;
     destination: z.ZodString;
     destinationIso2: z.ZodString;
     destinationName: z.ZodString;
@@ -1324,6 +1813,7 @@ declare const package_: z.ZodLazy<z.ZodObject<{
     destinationIso2: string;
     id: string;
     dataLimitInBytes: number;
+    dataLimitInGb: number;
     priceInCents: number;
     destinationName: string;
 }, {
@@ -1331,6 +1821,7 @@ declare const package_: z.ZodLazy<z.ZodObject<{
     destinationIso2: string;
     id: string;
     dataLimitInBytes: number;
+    dataLimitInGb: number;
     priceInCents: number;
     destinationName: string;
 }>>;
@@ -1339,6 +1830,7 @@ declare const package_: z.ZodLazy<z.ZodObject<{
  * @typedef  {Package_} package_
  * @property {string} - ID of the package
  * @property {number} - Size of the package in Bytes
+ * @property {number} - Size of the package in GB
  * @property {string} - ISO3 representation of the package's destination.
  * @property {string} - ISO2 representation of the package's destination.
  * @property {string} - Name of the package's destination
@@ -1347,7 +1839,9 @@ declare const package_: z.ZodLazy<z.ZodObject<{
 type Package_ = z.infer<typeof package_>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the PurchasesEsim model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const purchasesEsim: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -1364,7 +1858,9 @@ declare const purchasesEsim: z.ZodLazy<z.ZodObject<{
 type PurchasesEsim = z.infer<typeof purchasesEsim>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseOkResponsePurchase model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseOkResponsePurchase: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -1405,7 +1901,9 @@ declare const createPurchaseOkResponsePurchase: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseOkResponsePurchase = z.infer<typeof createPurchaseOkResponsePurchase>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the CreatePurchaseOkResponseProfile model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const createPurchaseOkResponseProfile: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -1430,7 +1928,9 @@ declare const createPurchaseOkResponseProfile: z.ZodLazy<z.ZodObject<{
 type CreatePurchaseOkResponseProfile = z.infer<typeof createPurchaseOkResponseProfile>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TopUpEsimOkResponsePurchase model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const topUpEsimOkResponsePurchase: z.ZodLazy<z.ZodObject<{
     id: z.ZodString;
@@ -1471,7 +1971,9 @@ declare const topUpEsimOkResponsePurchase: z.ZodLazy<z.ZodObject<{
 type TopUpEsimOkResponsePurchase = z.infer<typeof topUpEsimOkResponsePurchase>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TopUpEsimOkResponseProfile model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const topUpEsimOkResponseProfile: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -1488,7 +1990,9 @@ declare const topUpEsimOkResponseProfile: z.ZodLazy<z.ZodObject<{
 type TopUpEsimOkResponseProfile = z.infer<typeof topUpEsimOkResponseProfile>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetEsimOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getEsimOkResponse: z.ZodLazy<z.ZodObject<{
     esim: z.ZodLazy<z.ZodObject<{
@@ -1549,7 +2053,9 @@ interface GetEsimParams {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetEsimDeviceOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getEsimDeviceOkResponse: z.ZodLazy<z.ZodObject<{
     device: z.ZodLazy<z.ZodObject<{
@@ -1591,7 +2097,9 @@ declare const getEsimDeviceOkResponse: z.ZodLazy<z.ZodObject<{
 type GetEsimDeviceOkResponse = z.infer<typeof getEsimDeviceOkResponse>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetEsimHistoryOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getEsimHistoryOkResponse: z.ZodLazy<z.ZodObject<{
     esim: z.ZodLazy<z.ZodObject<{
@@ -1650,6 +2158,11 @@ declare const getEsimHistoryOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type GetEsimHistoryOkResponse = z.infer<typeof getEsimHistoryOkResponse>;
 
+/**
+ * Service class for ESimService operations.
+ * Provides methods to interact with ESimService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class ESimService extends BaseService {
     /**
      * Get eSIM
@@ -1675,7 +2188,9 @@ declare class ESimService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetEsimOkResponseEsim model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getEsimOkResponseEsim: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -1716,7 +2231,9 @@ declare const getEsimOkResponseEsim: z.ZodLazy<z.ZodObject<{
 type GetEsimOkResponseEsim = z.infer<typeof getEsimOkResponseEsim>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the Device model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const device: z.ZodLazy<z.ZodObject<{
     oem: z.ZodString;
@@ -1745,7 +2262,9 @@ declare const device: z.ZodLazy<z.ZodObject<{
 type Device = z.infer<typeof device>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetEsimHistoryOkResponseEsim model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getEsimHistoryOkResponseEsim: z.ZodLazy<z.ZodObject<{
     iccid: z.ZodString;
@@ -1786,7 +2305,9 @@ declare const getEsimHistoryOkResponseEsim: z.ZodLazy<z.ZodObject<{
 type GetEsimHistoryOkResponseEsim = z.infer<typeof getEsimHistoryOkResponseEsim>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the History model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const history: z.ZodLazy<z.ZodObject<{
     status: z.ZodString;
@@ -1811,7 +2332,9 @@ declare const history: z.ZodLazy<z.ZodObject<{
 type History = z.infer<typeof history>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the TokenOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const tokenOkResponse: z.ZodLazy<z.ZodObject<{
     token: z.ZodString;
@@ -1827,6 +2350,11 @@ declare const tokenOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type TokenOkResponse = z.infer<typeof tokenOkResponse>;
 
+/**
+ * Service class for IFrameService operations.
+ * Provides methods to interact with IFrameService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class IFrameService extends BaseService {
     /**
      * Generate a new token to be used in the iFrame
@@ -1837,7 +2365,9 @@ declare class IFrameService extends BaseService {
 }
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetAccessTokenRequest model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getAccessTokenRequest: z.ZodLazy<z.ZodObject<{
     grantType: z.ZodOptional<z.ZodString>;
@@ -1862,7 +2392,9 @@ declare const getAccessTokenRequest: z.ZodLazy<z.ZodObject<{
 type GetAccessTokenRequest = z.infer<typeof getAccessTokenRequest>;
 
 /**
- * The shape of the model inside the application code - what the users use
+ * Zod schema for the GetAccessTokenOkResponse model.
+ * Defines the structure and validation rules for this data type.
+ * This is the shape used in application code - what developers interact with.
  */
 declare const getAccessTokenOkResponse: z.ZodLazy<z.ZodObject<{
     accessToken: z.ZodOptional<z.ZodString>;
@@ -1886,6 +2418,11 @@ declare const getAccessTokenOkResponse: z.ZodLazy<z.ZodObject<{
  */
 type GetAccessTokenOkResponse = z.infer<typeof getAccessTokenOkResponse>;
 
+/**
+ * Service class for OAuthService operations.
+ * Provides methods to interact with OAuthService-related API endpoints.
+ * All methods return promises and handle request/response serialization automatically.
+ */
 declare class OAuthService extends BaseService {
     /**
      * This endpoint was added by liblab