celitech-sdk 1.1.85 → 1.1.87

package/dist/index.mjs

@@ -0,0 +1,2114 @@
+// src/services/destinations/destinations.ts
+import { z as z4 } from "zod";
+
+// src/http/handlers/handler-chain.ts
+var RequestHandlerChain = class {
+  constructor() {
+    this.handlers = [];
+  }
+  addHandler(handler) {
+    if (this.handlers.length > 0) {
+      const previousHandler = this.handlers[this.handlers.length - 1];
+      previousHandler.next = handler;
+    }
+    this.handlers.push(handler);
+  }
+  async callChain(request) {
+    if (!this.handlers.length) {
+      throw new Error("No handlers added to the chain");
+    }
+    return this.handlers[0].handle(request);
+  }
+};
+
+// src/http/error.ts
+var HttpError = class extends Error {
+  constructor(metadata, error) {
+    super(error);
+    this.error = metadata.statusText;
+    this.metadata = metadata;
+  }
+};
+
+// src/http/hooks/custom-hook.ts
+var CURRENT_TOKEN = "";
+var CURRENT_EXPIRY = -1;
+var CustomHook = class {
+  async getToken(clientId, clientSecret) {
+    const tokenUrl = "https://auth.celitech.net/oauth2/token";
+    const headers = {
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    const body = {
+      client_id: clientId,
+      client_secret: clientSecret,
+      grant_type: "client_credentials"
+    };
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers,
+      body: new URLSearchParams(body)
+    });
+    return response.json();
+  }
+  async beforeRequest(request, params) {
+    console.log("request", request);
+    console.log("params", params);
+    const clientId = params.get("clientId") || "";
+    const clientSecret = params.get("clientSecret") || "";
+    console.log("clientId", clientId);
+    console.log("clientSecret", clientSecret);
+    if (!clientId || !clientSecret) {
+      throw new Error("Missing clientId and/or clientSecret constructor parameters");
+    }
+    if (!CURRENT_TOKEN || CURRENT_EXPIRY < Date.now()) {
+      const tokenResponse = await this.getToken(clientId, clientSecret);
+      console.log("tokenResponse", tokenResponse);
+      if (tokenResponse.error) {
+        throw new Error(tokenResponse.error);
+      }
+      const { expires_in, access_token } = tokenResponse;
+      if (!expires_in || !access_token) {
+        throw new Error("There is an issue with getting the oauth token");
+      }
+      CURRENT_EXPIRY = Date.now() + expires_in * 1e3;
+      CURRENT_TOKEN = access_token;
+    }
+    const authorization = `Bearer ${CURRENT_TOKEN}`;
+    console.log("authorization", authorization);
+    if (!request.headers) {
+      request.headers = /* @__PURE__ */ new Map();
+    }
+    request.headers.set("Authorization", authorization);
+    return request;
+  }
+  async afterResponse(request, response, params) {
+    return response;
+  }
+  async onError(request, response, params) {
+    return new CustomHttpError("a custom error message", response.metadata);
+  }
+};
+var CustomHttpError = class {
+  constructor(error, metadata) {
+    this.error = error;
+    this.metadata = metadata;
+  }
+};
+
+// src/http/serialization/base-serializer.ts
+var Serializer = class {
+  serializeValue(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);
+  }
+  serializePrimitive(param) {
+    if (param.style === "label" /* LABEL */) {
+      return `.${param.value}`;
+    } else if (param.style === "matrix" /* MATRIX */) {
+      return `;${param.key}=${param.value}`;
+    } else if (param.style === "form" /* FORM */) {
+      return `${encodeURIComponent(param.key || "")}=${encodeURIComponent(`${param.value}`)}`;
+    }
+    return `${param.value}`;
+  }
+  serializeArray(value, param) {
+    if (param.explode) {
+      this.serializeArrayExploded(value, param);
+      return this.serializeArrayExploded(value, param);
+    }
+    if (param.style === "simple" /* SIMPLE */) {
+      return `${value.join(",")}`;
+    } else if (param.style === "label" /* LABEL */) {
+      return `.${value.join(",")}`;
+    } else if (param.style === "matrix" /* MATRIX */) {
+      return `;${param.key}=${value.join(",")}`;
+    } else if (param.style === "form" /* FORM */) {
+      return `${encodeURIComponent(param.key || "")}=${encodeURIComponent(value.join(","))}`;
+    } else if (param.style === "space_delimited" /* SPACE_DELIMITED */) {
+      return `${param.key}=${value.join(" ")}`;
+    } else if (param.style === "pipe_delimited" /* PIPE_DELIMITED */) {
+      return `${param.key}=${value.join("|")}`;
+    }
+    return `${value.join(",")}`;
+  }
+  serializeArrayExploded(value, param) {
+    if (param.style === "simple" /* SIMPLE */) {
+      return value.map((val) => `${val}`).join(",");
+    } else if (param.style === "label" /* LABEL */) {
+      return value.map((val) => `.${val}`).join("");
+    } else if (param.style === "matrix" /* MATRIX */) {
+      return value.map((val) => `;${param.key}=${val}`).join("");
+    } else if (param.style === "form" /* FORM */ || param.style === "space_delimited" /* SPACE_DELIMITED */ || param.style === "pipe_delimited" /* PIPE_DELIMITED */) {
+      return value.map((val) => `${encodeURIComponent(param.key || "")}=${encodeURIComponent(`${val}`)}`).join("&");
+    }
+    return `${value.join(",")}`;
+  }
+  serializeObject(obj, param) {
+    if (param.explode) {
+      if (param.style === "simple" /* SIMPLE */) {
+        return Object.entries(obj).map(([key, val]) => `${key}=${val}`).join(",");
+      } else if (param.style === "label" /* LABEL */) {
+        return Object.entries(obj).map(([key, val]) => `.${key}=${val}`).join("");
+      } else if (param.style === "matrix" /* MATRIX */) {
+        return Object.entries(obj).map(([key, val]) => `;${key}=${val}`).join("");
+      } else if (param.style === "form" /* FORM */) {
+        return Object.entries(obj).map(([key, val]) => `${key}=${val}`).join("&");
+      }
+    }
+    if (param.style === "simple" /* SIMPLE */) {
+      return Object.entries(obj).map(([key, val]) => `${key},${val}`).join(",");
+    } else if (param.style === "label" /* LABEL */) {
+      return `.${Object.entries(obj).map(([key, val]) => `${key},${val}`).join(",")}`;
+    } else if (param.style === "matrix" /* MATRIX */) {
+      return `;${param.key}=${Object.entries(obj).map(([key, val]) => `${key},${val}`).join(",")}`;
+    } else if (param.style === "form" /* FORM */) {
+      return Object.entries(obj).map(([key, val]) => `${key}=${val}`).join("&");
+    } else if (param.style === "deep_object" /* DEEP_OBJECT */) {
+      return Object.entries(obj).map(([key, val]) => {
+        return `${param.key}[${key}]=${val}`;
+      }).join("&");
+    }
+    return Object.entries(obj).map(([key, val]) => `${key}=${val}`).join("&");
+  }
+  isNonNullObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+};
+
+// src/http/transport/transport-hook-adapter.ts
+var TransportHookAdapter = class {
+  constructor() {
+    this.hook = new CustomHook();
+  }
+  async beforeRequest(request, params) {
+    const hookRequest = this.requestToHookRequest(request);
+    const newRequest = await this.hook.beforeRequest(hookRequest, params);
+    const newTransportRequest = request.copy({
+      baseUrl: newRequest.baseUrl,
+      method: newRequest.method,
+      path: newRequest.path,
+      body: newRequest.body,
+      queryParams: this.hookParamsToTransportParams(newRequest.queryParams, request.queryParams, true),
+      headers: this.hookParamsToTransportParams(newRequest.headers, request.headers, false)
+    });
+    return newTransportRequest;
+  }
+  async afterResponse(request, response, params) {
+    const hookRequest = this.requestToHookRequest(request);
+    return this.hook.afterResponse(hookRequest, response, params);
+  }
+  async onError(request, response, params) {
+    const hookRequest = this.requestToHookRequest(request);
+    return this.hook.onError(hookRequest, response, params);
+  }
+  requestToHookRequest(request) {
+    const hookHeaders = /* @__PURE__ */ new Map();
+    request.headers.forEach((header, key) => {
+      hookHeaders.set(key, header.value);
+    });
+    const hookQueryParams = /* @__PURE__ */ new Map();
+    request.queryParams.forEach((queryParam, key) => {
+      hookQueryParams.set(key, queryParam.value);
+    });
+    const hookRequest = {
+      baseUrl: request.baseUrl,
+      method: request.method,
+      path: request.path,
+      headers: hookHeaders,
+      body: request.body,
+      queryParams: hookQueryParams
+    };
+    return hookRequest;
+  }
+  hookParamsToTransportParams(hookParams, originalTransportParams, encode) {
+    const transportParams = /* @__PURE__ */ new Map();
+    hookParams.forEach((hookParamValue, hookParamKey) => {
+      var _a, _b;
+      const requestParam = originalTransportParams.get(hookParamKey);
+      transportParams.set(hookParamKey, {
+        key: hookParamKey,
+        value: hookParamValue,
+        encode: (_a = requestParam == null ? void 0 : requestParam.encode) != null ? _a : false,
+        style: (requestParam == null ? void 0 : requestParam.style) || "none" /* NONE */,
+        explode: (_b = requestParam == null ? void 0 : requestParam.explode) != null ? _b : false
+      });
+    });
+    return transportParams;
+  }
+};
+
+// src/http/handlers/hook-handler.ts
+var HookHandler = class {
+  constructor(hook) {
+    this.hook = hook;
+  }
+  async handle(request) {
+    if (!this.next) {
+      throw new Error("No next handler set in hook handler.");
+    }
+    const hook = new TransportHookAdapter();
+    const hookParams = this.getHookParams(request);
+    const nextRequest = await hook.beforeRequest(request, hookParams);
+    const response = await this.next.handle(nextRequest);
+    if (response.metadata.status < 400) {
+      return await hook.afterResponse(nextRequest, response, hookParams);
+    }
+    const error = await hook.onError(nextRequest, response, hookParams);
+    throw new HttpError(error.metadata, error.error);
+  }
+  getHookParams(request) {
+    const hookParams = /* @__PURE__ */ new Map();
+    hookParams.set("clientId", request.config.clientId || "");
+    hookParams.set("clientSecret", request.config.clientSecret || "");
+    return hookParams;
+  }
+};
+
+// src/http/handlers/response-validation-handler.ts
+import { ZodUndefined } from "zod";
+var ResponseValidationHandler = class {
+  async handle(request) {
+    const response = await this.next.handle(request);
+    if (!this.hasContent(request, response)) {
+      return response;
+    }
+    if (request.responseContentType === "json" /* Json */) {
+      const decodedBody = new TextDecoder().decode(response.raw);
+      const json = JSON.parse(decodedBody);
+      return {
+        ...response,
+        data: this.validate(request, json)
+      };
+    } else if (request.responseContentType === "binary" /* Binary */ || request.responseContentType === "image" /* Image */) {
+      return {
+        ...response,
+        data: this.validate(request, response.raw)
+      };
+    } else if (request.responseContentType === "text" /* Text */ || request.responseContentType === "xml" /* Xml */) {
+      const text = new TextDecoder().decode(response.raw);
+      return {
+        ...response,
+        data: this.validate(request, text)
+      };
+    } else if (request.responseContentType === "form" /* FormUrlEncoded */) {
+      const urlEncoded = this.fromUrlEncoded(new TextDecoder().decode(response.raw));
+      return {
+        ...response,
+        data: this.validate(request, urlEncoded)
+      };
+    } else if (request.responseContentType === "multipartFormData" /* MultipartFormData */) {
+      const formData = this.fromFormData(response.raw);
+      return {
+        ...response,
+        data: this.validate(request, formData)
+      };
+    } else {
+      const decodedBody = new TextDecoder().decode(response.raw);
+      const json = JSON.parse(decodedBody);
+      return {
+        ...response,
+        data: this.validate(request, json)
+      };
+    }
+  }
+  validate(request, data) {
+    var _a;
+    if ((_a = request.validation) == null ? void 0 : _a.responseValidation) {
+      return request.responseSchema.parse(data);
+    }
+    return data;
+  }
+  hasContent(request, response) {
+    return !!request.responseSchema && !(request.responseSchema instanceof ZodUndefined) && response.metadata.status !== 204;
+  }
+  fromUrlEncoded(urlEncodedData) {
+    const pairs = urlEncodedData.split("&");
+    const result = {};
+    pairs.forEach((pair) => {
+      const [key, value] = pair.split("=");
+      if (key && value !== void 0) {
+        result[decodeURIComponent(key)] = decodeURIComponent(value);
+      }
+    });
+    return result;
+  }
+  fromFormData(arrayBuffer) {
+    const decoder = new TextDecoder();
+    const text = decoder.decode(arrayBuffer);
+    const boundary = text.split("\r\n")[0];
+    const parts = text.split(boundary).slice(1, -1);
+    const formDataObj = {};
+    parts.forEach((part) => {
+      const [header, value] = part.split("\r\n\r\n");
+      const nameMatch = header.match(/name="([^"]+)"/);
+      if (nameMatch) {
+        const name = nameMatch[1].trim();
+        formDataObj[name] = (value == null ? void 0 : value.trim()) || "";
+      }
+    });
+    return formDataObj;
+  }
+};
+
+// src/http/handlers/request-validation-handler.ts
+var RequestValidationHandler = class {
+  async handle(request) {
+    var _a, _b;
+    if (!this.next) {
+      throw new Error("No next handler set in ContentTypeHandler.");
+    }
+    if (request.requestContentType === "json" /* Json */) {
+      request.body = JSON.stringify((_a = request.requestSchema) == null ? void 0 : _a.parse(request.body));
+    } else if (request.requestContentType === "xml" /* Xml */ || request.requestContentType === "binary" /* Binary */ || request.requestContentType === "text" /* Text */) {
+      request.body = request.body;
+    } else if (request.requestContentType === "form" /* FormUrlEncoded */) {
+      request.body = this.toFormUrlEncoded(request.body);
+    } else if (request.requestContentType === "multipartFormData" /* MultipartFormData */) {
+      request.body = this.toFormData(request.body);
+    } else {
+      request.body = JSON.stringify((_b = request.requestSchema) == null ? void 0 : _b.parse(request.body));
+    }
+    return await this.next.handle(request);
+  }
+  toFormUrlEncoded(body) {
+    if (body === void 0) {
+      return "";
+    }
+    if (typeof body === "string") {
+      return body;
+    }
+    if (body instanceof URLSearchParams) {
+      return body.toString();
+    }
+    if (body instanceof FormData) {
+      const params = new URLSearchParams();
+      body.forEach((value, key) => {
+        params.append(key, value.toString());
+      });
+      return params.toString();
+    }
+    return "";
+  }
+  toFormData(body) {
+    const formData = new FormData();
+    Object.keys(body).forEach((key) => {
+      const value = body[key];
+      if (Array.isArray(value)) {
+        value.forEach((v, i) => formData.append(`${key}[${i}]`, v));
+      } else if (value instanceof ArrayBuffer) {
+        formData.append(key, new Blob([value]));
+      } else {
+        formData.append(key, value);
+      }
+    });
+    return formData;
+  }
+};
+
+// src/http/transport/request-axios-adapter.ts
+import axios, { isAxiosError } from "axios";
+var RequestAxiosAdapter = class {
+  constructor(request) {
+    this.request = request;
+    this.config = {
+      responseType: "arraybuffer"
+    };
+    this.setHeaders();
+    this.setTimeout();
+  }
+  async send() {
+    const method = this.getMethod();
+    const { body } = this.request;
+    let axiosResponse;
+    try {
+      if (this.request.method === "POST" || this.request.method === "PUT" || this.request.method === "PATCH") {
+        axiosResponse = await method(this.request.constructFullUrl(), body, this.config);
+      } else {
+        axiosResponse = await method(this.request.constructFullUrl(), this.config);
+      }
+    } catch (err) {
+      if (isAxiosError(err) && err.response) {
+        axiosResponse = err.response;
+      } else {
+        throw err;
+      }
+    }
+    const headerRecord = {};
+    Object.keys(axiosResponse.headers).forEach((key) => {
+      headerRecord[key] = axiosResponse.headers[key];
+    });
+    const metadata = {
+      status: axiosResponse.status,
+      statusText: axiosResponse.statusText || "",
+      headers: headerRecord
+    };
+    if (metadata.status >= 400) {
+      throw new HttpError(metadata);
+    }
+    return {
+      metadata,
+      raw: axiosResponse.data.buffer.slice(
+        axiosResponse.data.byteOffset,
+        axiosResponse.data.byteOffset + axiosResponse.data.byteLength
+      )
+    };
+  }
+  getMethod() {
+    if (this.request.method === "POST") {
+      return axios.post;
+    } else if (this.request.method === "GET") {
+      return axios.get;
+    } else if (this.request.method === "PUT") {
+      return axios.put;
+    } else if (this.request.method === "DELETE") {
+      return axios.delete;
+    } else if (this.request.method === "PATCH") {
+      return axios.patch;
+    } else if (this.request.method === "HEAD") {
+      return axios.head;
+    }
+    throw new Error("invalid method!!!!");
+  }
+  setHeaders() {
+    if (!this.request.headers) {
+      return;
+    }
+    const headersRecord = {};
+    new Headers(this.request.getHeaders()).forEach((value, key) => {
+      headersRecord[key] = value;
+    });
+    this.config = {
+      ...this.config,
+      headers: headersRecord
+    };
+  }
+  setTimeout() {
+    this.config = {
+      ...this.config,
+      timeout: this.request.config.timeout
+    };
+  }
+};
+
+// src/http/handlers/terminating-handler.ts
+var TerminatingHandler = class {
+  async handle(request) {
+    return new RequestAxiosAdapter(request).send();
+  }
+};
+
+// src/http/handlers/retry-handler.ts
+var RetryHandler = class {
+  async handle(request) {
+    if (!this.next) {
+      throw new Error("No next handler set in retry handler.");
+    }
+    for (let attempt = 1; attempt <= request.retry.attempts; attempt++) {
+      try {
+        return await this.next.handle(request);
+      } catch (error) {
+        if (!this.shouldRetry(error) || attempt === request.retry.attempts) {
+          throw error;
+        }
+        await this.delay(request.retry.delayMs);
+      }
+    }
+    throw new Error("Error retrying request.");
+  }
+  shouldRetry(error) {
+    return error instanceof HttpError && (error.metadata.status >= 500 || error.metadata.status === 408);
+  }
+  delay(delayMs) {
+    if (!delayMs) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), delayMs);
+    });
+  }
+};
+
+// src/http/client.ts
+var HttpClient = class {
+  constructor(config, hook = new CustomHook()) {
+    this.config = config;
+    this.requestHandlerChain = new RequestHandlerChain();
+    this.requestHandlerChain.addHandler(new ResponseValidationHandler());
+    this.requestHandlerChain.addHandler(new RequestValidationHandler());
+    this.requestHandlerChain.addHandler(new RetryHandler());
+    this.requestHandlerChain.addHandler(new HookHandler(hook));
+    this.requestHandlerChain.addHandler(new TerminatingHandler());
+  }
+  call(request) {
+    return this.requestHandlerChain.callChain(request);
+  }
+  setBaseUrl(url) {
+    this.config.baseUrl = url;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+};
+
+// src/services/base-service.ts
+var BaseService = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new HttpClient(this.config);
+  }
+  set baseUrl(baseUrl) {
+    this.config.baseUrl = baseUrl;
+  }
+  set environment(environment) {
+    this.config.environment = environment;
+  }
+  set timeout(timeout) {
+    this.config.timeout = timeout;
+  }
+  set clientId(clientId) {
+    this.config.clientId = clientId;
+  }
+  set clientSecret(clientSecret) {
+    this.config.clientSecret = clientSecret;
+  }
+};
+
+// src/http/transport/request-builder.ts
+import z from "zod";
+
+// src/http/serialization/path-serializer.ts
+var PathSerializer = class extends Serializer {
+  serialize(pathPattern, pathArguments) {
+    let serializedPath = pathPattern;
+    pathArguments.forEach((param) => {
+      serializedPath = serializedPath.replace(`{${param.key}}`, `${this.serializeValue(param)}`);
+    });
+    return serializedPath;
+  }
+};
+
+// src/http/serialization/query-serializer.ts
+var QuerySerializer = class extends Serializer {
+  serialize(queryParams) {
+    if (!queryParams || !queryParams.size) {
+      return "";
+    }
+    const query = [];
+    queryParams.forEach((param) => {
+      return query.push(`${this.serializeValue(param)}`);
+    });
+    return query.length ? `?${query.join("&")}` : "";
+  }
+};
+
+// src/http/serialization/header-serializer.ts
+var HeaderSerializer = class extends Serializer {
+  serialize(headerParams) {
+    if (!headerParams || !headerParams.size) {
+      return void 0;
+    }
+    const headers = {};
+    headerParams.forEach((param) => {
+      if (!param.key) {
+        return;
+      }
+      headers[param.key] = this.serializeValue(param);
+    });
+    return headers;
+  }
+};
+
+// src/http/transport/request.ts
+var Request = class {
+  constructor(params) {
+    this.baseUrl = "";
+    this.headers = /* @__PURE__ */ new Map();
+    this.queryParams = /* @__PURE__ */ new Map();
+    this.pathParams = /* @__PURE__ */ new Map();
+    this.validation = {};
+    this.retry = {};
+    this.baseUrl = params.baseUrl;
+    this.method = params.method;
+    this.pathPattern = params.path;
+    this.body = params.body;
+    this.path = this.constructPath();
+    this.config = params.config;
+    this.pathParams = params.pathParams;
+    this.headers = params.headers;
+    this.queryParams = params.queryParams;
+    this.responseSchema = params.responseSchema;
+    this.requestSchema = params.requestSchema;
+    this.requestContentType = params.requestContentType;
+    this.responseContentType = params.responseContentType;
+    this.retry = params.retry;
+    this.validation = params.validation;
+  }
+  addHeaderParam(key, param) {
+    if (param.value === void 0) {
+      return;
+    }
+    if (param.explode === void 0) {
+      param.explode = false;
+    }
+    if (param.style === void 0) {
+      param.style = "simple" /* SIMPLE */;
+    }
+    if (param.encode === void 0) {
+      param.encode = false;
+    }
+    this.headers.set(key, param);
+  }
+  addQueryParam(key, param) {
+    if (param.value === void 0) {
+      return;
+    }
+    if (param.explode === void 0) {
+      param.explode = true;
+    }
+    if (param.style === void 0) {
+      param.style = "form" /* FORM */;
+    }
+    if (param.encode === void 0) {
+      param.encode = true;
+    }
+    this.queryParams.set(key, param);
+  }
+  addPathParam(key, param) {
+    if (param.value === void 0) {
+      return;
+    }
+    if (param.explode === void 0) {
+      param.explode = false;
+    }
+    if (param.style === void 0) {
+      param.style = "simple" /* SIMPLE */;
+    }
+    if (param.encode === void 0) {
+      param.encode = true;
+    }
+    this.pathParams.set(key, param);
+  }
+  addBody(body) {
+    if (body === void 0) {
+      return;
+    }
+    this.body = body;
+  }
+  updateFromHookRequest(hookRequest) {
+    this.baseUrl = hookRequest.baseUrl;
+    this.method = hookRequest.method;
+    this.path = hookRequest.path;
+    this.body = hookRequest.body;
+  }
+  toHookRequest() {
+    return {
+      baseUrl: this.baseUrl,
+      method: this.method,
+      path: this.path,
+      headers: this.headers,
+      body: this.body,
+      queryParams: this.queryParams
+    };
+  }
+  constructFullUrl() {
+    const queryString = new QuerySerializer().serialize(this.queryParams);
+    const path = this.constructPath();
+    return `${this.baseUrl}${path}${queryString}`;
+  }
+  copy(overrides) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    const createRequestParams = {
+      baseUrl: (_a = overrides == null ? void 0 : overrides.baseUrl) != null ? _a : this.baseUrl,
+      method: (_b = overrides == null ? void 0 : overrides.method) != null ? _b : this.method,
+      path: (_c = overrides == null ? void 0 : overrides.path) != null ? _c : this.path,
+      body: (_d = overrides == null ? void 0 : overrides.body) != null ? _d : this.body,
+      config: (_e = overrides == null ? void 0 : overrides.config) != null ? _e : this.config,
+      pathParams: (_f = overrides == null ? void 0 : overrides.pathParams) != null ? _f : this.pathParams,
+      queryParams: (_g = overrides == null ? void 0 : overrides.queryParams) != null ? _g : this.queryParams,
+      headers: (_h = overrides == null ? void 0 : overrides.headers) != null ? _h : this.headers,
+      responseSchema: (_i = overrides == null ? void 0 : overrides.responseSchema) != null ? _i : this.responseSchema,
+      requestSchema: (_j = overrides == null ? void 0 : overrides.requestSchema) != null ? _j : this.requestSchema,
+      requestContentType: (_k = overrides == null ? void 0 : overrides.requestContentType) != null ? _k : this.requestContentType,
+      responseContentType: (_l = overrides == null ? void 0 : overrides.responseContentType) != null ? _l : this.responseContentType,
+      retry: (_m = overrides == null ? void 0 : overrides.retry) != null ? _m : this.retry,
+      validation: (_n = overrides == null ? void 0 : overrides.validation) != null ? _n : this.validation
+    };
+    return new Request({
+      ...createRequestParams,
+      ...overrides
+    });
+  }
+  getHeaders() {
+    if (!this.headers || !this.headers.size) {
+      return void 0;
+    }
+    return new HeaderSerializer().serialize(this.headers);
+  }
+  constructPath() {
+    return new PathSerializer().serialize(this.pathPattern, this.pathParams);
+  }
+};
+
+// src/http/transport/request-builder.ts
+var RequestBuilder = class {
+  constructor() {
+    this.params = {
+      baseUrl: "https://api.celitech.net/v1" /* DEFAULT */,
+      method: "GET",
+      path: "",
+      config: {},
+      responseSchema: z.any(),
+      requestSchema: z.any(),
+      requestContentType: "json" /* Json */,
+      responseContentType: "json" /* Json */,
+      retry: {
+        attempts: 3,
+        delayMs: 150
+      },
+      validation: {
+        responseValidation: true
+      },
+      pathParams: /* @__PURE__ */ new Map(),
+      queryParams: /* @__PURE__ */ new Map(),
+      headers: /* @__PURE__ */ new Map()
+    };
+  }
+  setRetryAttempts(sdkConfig, requestConfig) {
+    var _a, _b;
+    if (((_a = requestConfig == null ? void 0 : requestConfig.retry) == null ? void 0 : _a.attempts) !== void 0) {
+      this.params.retry.attempts = requestConfig.retry.attempts;
+    } else if (((_b = sdkConfig == null ? void 0 : sdkConfig.retry) == null ? void 0 : _b.attempts) !== void 0) {
+      this.params.retry.attempts = sdkConfig.retry.attempts;
+    }
+    return this;
+  }
+  setRetryDelayMs(sdkConfig, requestConfig) {
+    var _a, _b;
+    if (((_a = requestConfig == null ? void 0 : requestConfig.retry) == null ? void 0 : _a.delayMs) !== void 0) {
+      this.params.retry.delayMs = requestConfig.retry.delayMs;
+    } else if (((_b = sdkConfig == null ? void 0 : sdkConfig.retry) == null ? void 0 : _b.delayMs) !== void 0) {
+      this.params.retry.delayMs = sdkConfig.retry.delayMs;
+    }
+    return this;
+  }
+  setResponseValidation(sdkConfig, requestConfig) {
+    var _a, _b;
+    if (((_a = requestConfig == null ? void 0 : requestConfig.validation) == null ? void 0 : _a.responseValidation) !== void 0) {
+      this.params.validation.responseValidation = requestConfig.validation.responseValidation;
+    } else if (((_b = sdkConfig == null ? void 0 : sdkConfig.validation) == null ? void 0 : _b.responseValidation) !== void 0) {
+      this.params.validation.responseValidation = sdkConfig.validation.responseValidation;
+    }
+    return this;
+  }
+  setBaseUrl(sdkConfig) {
+    if ((sdkConfig == null ? void 0 : sdkConfig.baseUrl) !== void 0) {
+      this.params.baseUrl = sdkConfig.baseUrl;
+    }
+    return this;
+  }
+  setMethod(method) {
+    this.params.method = method;
+    return this;
+  }
+  setPath(path) {
+    this.params.path = path;
+    return this;
+  }
+  setConfig(config) {
+    this.params.config = config;
+    return this;
+  }
+  setRequestContentType(contentType) {
+    this.params.requestContentType = contentType;
+    return this;
+  }
+  setResponseContentType(contentType) {
+    this.params.responseContentType = contentType;
+    return this;
+  }
+  setRequestSchema(requestSchema) {
+    this.params.requestSchema = requestSchema;
+    return this;
+  }
+  setResponseSchema(responseSchema) {
+    this.params.responseSchema = responseSchema;
+    return this;
+  }
+  addBody(body) {
+    if (body !== void 0) {
+      this.params.body = body;
+    }
+    return this;
+  }
+  addPathParam(param) {
+    var _a, _b, _c;
+    if (param.value === void 0 || param.key === void 0) {
+      return this;
+    }
+    this.params.pathParams.set(param.key, {
+      key: param.key,
+      value: param.value,
+      explode: (_a = param.explode) != null ? _a : true,
+      style: (_b = param.style) != null ? _b : "simple" /* SIMPLE */,
+      encode: (_c = param.encode) != null ? _c : true
+    });
+    return this;
+  }
+  addQueryParam(param) {
+    var _a, _b, _c;
+    if (param.value === void 0 || param.key === void 0) {
+      return this;
+    }
+    this.params.queryParams.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 : true
+    });
+    return this;
+  }
+  addHeaderParam(param) {
+    var _a, _b, _c;
+    if (param.value === void 0 || param.key === void 0) {
+      return this;
+    }
+    this.params.headers.set(param.key, {
+      key: param.key,
+      value: param.value,
+      explode: (_a = param.explode) != null ? _a : true,
+      style: (_b = param.style) != null ? _b : "simple" /* SIMPLE */,
+      encode: (_c = param.encode) != null ? _c : false
+    });
+    return this;
+  }
+  build() {
+    return new Request(this.params);
+  }
+};
+
+// src/services/destinations/models/list-destinations-ok-response.ts
+import { z as z3 } from "zod";
+
+// src/services/destinations/models/destinations.ts
+import { z as z2 } from "zod";
+var destinations = z2.lazy(() => {
+  return z2.object({
+    name: z2.string().optional(),
+    destination: z2.string().optional(),
+    supportedCountries: z2.array(z2.string()).optional()
+  });
+});
+var destinationsResponse = z2.lazy(() => {
+  return z2.object({
+    name: z2.string().optional(),
+    destination: z2.string().optional(),
+    supportedCountries: z2.array(z2.string()).optional()
+  }).transform((data) => ({
+    name: data["name"],
+    destination: data["destination"],
+    supportedCountries: data["supportedCountries"]
+  }));
+});
+var destinationsRequest = z2.lazy(() => {
+  return z2.object({
+    name: z2.string().nullish(),
+    destination: z2.string().nullish(),
+    supportedCountries: z2.array(z2.string()).nullish()
+  }).transform((data) => ({
+    name: data["name"],
+    destination: data["destination"],
+    supportedCountries: data["supportedCountries"]
+  }));
+});
+
+// src/services/destinations/models/list-destinations-ok-response.ts
+var listDestinationsOkResponse = z3.lazy(() => {
+  return z3.object({
+    destinations: z3.array(destinations).optional()
+  });
+});
+var listDestinationsOkResponseResponse = z3.lazy(() => {
+  return z3.object({
+    destinations: z3.array(destinationsResponse).optional()
+  }).transform((data) => ({
+    destinations: data["destinations"]
+  }));
+});
+var listDestinationsOkResponseRequest = z3.lazy(() => {
+  return z3.object({ destinations: z3.array(destinationsRequest).nullish() }).transform((data) => ({
+    destinations: data["destinations"]
+  }));
+});
+
+// src/services/destinations/destinations.ts
+var DestinationsService = class extends BaseService {
+  /**
+   * List Destinations
+   * @returns {Promise<HttpResponse<ListDestinationsOkResponse>>} Successful Response
+   */
+  async listDestinations(requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/destinations").setRequestSchema(z4.any()).setResponseSchema(listDestinationsOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).build();
+    return this.client.call(request);
+  }
+};
+
+// src/services/packages/packages.ts
+import { z as z7 } from "zod";
+
+// src/services/packages/models/list-packages-ok-response.ts
+import { z as z6 } from "zod";
+
+// src/services/packages/models/packages.ts
+import { z as z5 } from "zod";
+var packages = z5.lazy(() => {
+  return z5.object({
+    id: z5.string().optional(),
+    destination: z5.string().optional(),
+    dataLimitInBytes: z5.number().optional(),
+    minDays: z5.number().optional(),
+    maxDays: z5.number().optional(),
+    priceInCents: z5.number().optional()
+  });
+});
+var packagesResponse = z5.lazy(() => {
+  return z5.object({
+    id: z5.string().optional(),
+    destination: z5.string().optional(),
+    dataLimitInBytes: z5.number().optional(),
+    minDays: z5.number().optional(),
+    maxDays: z5.number().optional(),
+    priceInCents: z5.number().optional()
+  }).transform((data) => ({
+    id: data["id"],
+    destination: data["destination"],
+    dataLimitInBytes: data["dataLimitInBytes"],
+    minDays: data["minDays"],
+    maxDays: data["maxDays"],
+    priceInCents: data["priceInCents"]
+  }));
+});
+var packagesRequest = z5.lazy(() => {
+  return z5.object({
+    id: z5.string().nullish(),
+    destination: z5.string().nullish(),
+    dataLimitInBytes: z5.number().nullish(),
+    minDays: z5.number().nullish(),
+    maxDays: z5.number().nullish(),
+    priceInCents: z5.number().nullish()
+  }).transform((data) => ({
+    id: data["id"],
+    destination: data["destination"],
+    dataLimitInBytes: data["dataLimitInBytes"],
+    minDays: data["minDays"],
+    maxDays: data["maxDays"],
+    priceInCents: data["priceInCents"]
+  }));
+});
+
+// src/services/packages/models/list-packages-ok-response.ts
+var listPackagesOkResponse = z6.lazy(() => {
+  return z6.object({
+    packages: z6.array(packages).optional(),
+    afterCursor: z6.string().optional().nullable()
+  });
+});
+var listPackagesOkResponseResponse = z6.lazy(() => {
+  return z6.object({
+    packages: z6.array(packagesResponse).optional(),
+    afterCursor: z6.string().optional().nullable()
+  }).transform((data) => ({
+    packages: data["packages"],
+    afterCursor: data["afterCursor"]
+  }));
+});
+var listPackagesOkResponseRequest = z6.lazy(() => {
+  return z6.object({ packages: z6.array(packagesRequest).nullish(), afterCursor: z6.string().nullish() }).transform((data) => ({
+    packages: data["packages"],
+    afterCursor: data["afterCursor"]
+  }));
+});
+
+// src/services/packages/packages.ts
+var PackagesService = class extends BaseService {
+  /**
+   * List Packages
+   * @param {string} [destination] - ISO representation of the package's destination.
+   * @param {string} [startDate] - 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.
+   * @param {string} [endDate] - End date of the package's validity in the format 'yyyy-MM-dd'. End date can be maximum 90 days after Start date.
+   * @param {string} [afterCursor] - To get the next batch of results, use this parameter. It tells the API where to start fetching data after the last item you received. It helps you avoid repeats and efficiently browse through large sets of data.
+   * @param {number} [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} [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} [endTime] - Epoch value representing the end time of the package's validity. End time can be maximum 90 days after Start time
+   * @param {number} [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
+   * @returns {Promise<HttpResponse<ListPackagesOkResponse>>} Successful Response
+   */
+  async listPackages(params, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/packages").setRequestSchema(z7.any()).setResponseSchema(listPackagesOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addQueryParam({
+      key: "destination",
+      value: params == null ? void 0 : params.destination
+    }).addQueryParam({
+      key: "startDate",
+      value: params == null ? void 0 : params.startDate
+    }).addQueryParam({
+      key: "endDate",
+      value: params == null ? void 0 : params.endDate
+    }).addQueryParam({
+      key: "afterCursor",
+      value: params == null ? void 0 : params.afterCursor
+    }).addQueryParam({
+      key: "limit",
+      value: params == null ? void 0 : params.limit
+    }).addQueryParam({
+      key: "startTime",
+      value: params == null ? void 0 : params.startTime
+    }).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);
+  }
+};
+
+// src/services/purchases/purchases.ts
+import { z as z23 } from "zod";
+
+// src/services/purchases/models/list-purchases-ok-response.ts
+import { z as z11 } from "zod";
+
+// src/services/purchases/models/purchases.ts
+import { z as z10 } from "zod";
+
+// src/services/purchases/models/package_.ts
+import { z as z8 } from "zod";
+var package_ = z8.lazy(() => {
+  return z8.object({
+    id: z8.string().optional(),
+    dataLimitInBytes: z8.number().optional(),
+    destination: z8.string().optional(),
+    destinationName: z8.string().optional(),
+    priceInCents: z8.number().optional()
+  });
+});
+var packageResponse = z8.lazy(() => {
+  return z8.object({
+    id: z8.string().optional(),
+    dataLimitInBytes: z8.number().optional(),
+    destination: z8.string().optional(),
+    destinationName: z8.string().optional(),
+    priceInCents: z8.number().optional()
+  }).transform((data) => ({
+    id: data["id"],
+    dataLimitInBytes: data["dataLimitInBytes"],
+    destination: data["destination"],
+    destinationName: data["destinationName"],
+    priceInCents: data["priceInCents"]
+  }));
+});
+var packageRequest = z8.lazy(() => {
+  return z8.object({
+    id: z8.string().nullish(),
+    dataLimitInBytes: z8.number().nullish(),
+    destination: z8.string().nullish(),
+    destinationName: z8.string().nullish(),
+    priceInCents: z8.number().nullish()
+  }).transform((data) => ({
+    id: data["id"],
+    dataLimitInBytes: data["dataLimitInBytes"],
+    destination: data["destination"],
+    destinationName: data["destinationName"],
+    priceInCents: data["priceInCents"]
+  }));
+});
+
+// src/services/purchases/models/purchases-esim.ts
+import { z as z9 } from "zod";
+var purchasesEsim = z9.lazy(() => {
+  return z9.object({
+    iccid: z9.string().min(18).max(22).optional()
+  });
+});
+var purchasesEsimResponse = z9.lazy(() => {
+  return z9.object({
+    iccid: z9.string().min(18).max(22).optional()
+  }).transform((data) => ({
+    iccid: data["iccid"]
+  }));
+});
+var purchasesEsimRequest = z9.lazy(() => {
+  return z9.object({ iccid: z9.string().nullish() }).transform((data) => ({
+    iccid: data["iccid"]
+  }));
+});
+
+// src/services/purchases/models/purchases.ts
+var purchases = z10.lazy(() => {
+  return z10.object({
+    id: z10.string().optional(),
+    startDate: z10.string().optional(),
+    endDate: z10.string().optional(),
+    createdDate: z10.string().optional(),
+    startTime: z10.number().optional(),
+    endTime: z10.number().optional(),
+    createdAt: z10.number().optional(),
+    package: package_.optional(),
+    esim: purchasesEsim.optional(),
+    source: z10.string().optional(),
+    referenceId: z10.string().optional()
+  });
+});
+var purchasesResponse = z10.lazy(() => {
+  return z10.object({
+    id: z10.string().optional(),
+    startDate: z10.string().optional(),
+    endDate: z10.string().optional(),
+    createdDate: z10.string().optional(),
+    startTime: z10.number().optional(),
+    endTime: z10.number().optional(),
+    createdAt: z10.number().optional(),
+    package: packageResponse.optional(),
+    esim: purchasesEsimResponse.optional(),
+    source: z10.string().optional(),
+    referenceId: z10.string().optional()
+  }).transform((data) => ({
+    id: data["id"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"],
+    createdAt: data["createdAt"],
+    package: data["package"],
+    esim: data["esim"],
+    source: data["source"],
+    referenceId: data["referenceId"]
+  }));
+});
+var purchasesRequest = z10.lazy(() => {
+  return z10.object({
+    id: z10.string().nullish(),
+    startDate: z10.string().nullish(),
+    endDate: z10.string().nullish(),
+    createdDate: z10.string().nullish(),
+    startTime: z10.number().nullish(),
+    endTime: z10.number().nullish(),
+    createdAt: z10.number().nullish(),
+    package: packageRequest.nullish(),
+    esim: purchasesEsimRequest.nullish(),
+    source: z10.string().nullish(),
+    referenceId: z10.string().nullish()
+  }).transform((data) => ({
+    id: data["id"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"],
+    createdAt: data["createdAt"],
+    package: data["package"],
+    esim: data["esim"],
+    source: data["source"],
+    referenceId: data["referenceId"]
+  }));
+});
+
+// src/services/purchases/models/list-purchases-ok-response.ts
+var listPurchasesOkResponse = z11.lazy(() => {
+  return z11.object({
+    purchases: z11.array(purchases).optional(),
+    afterCursor: z11.string().optional().nullable()
+  });
+});
+var listPurchasesOkResponseResponse = z11.lazy(() => {
+  return z11.object({
+    purchases: z11.array(purchasesResponse).optional(),
+    afterCursor: z11.string().optional().nullable()
+  }).transform((data) => ({
+    purchases: data["purchases"],
+    afterCursor: data["afterCursor"]
+  }));
+});
+var listPurchasesOkResponseRequest = z11.lazy(() => {
+  return z11.object({ purchases: z11.array(purchasesRequest).nullish(), afterCursor: z11.string().nullish() }).transform((data) => ({
+    purchases: data["purchases"],
+    afterCursor: data["afterCursor"]
+  }));
+});
+
+// src/services/purchases/models/create-purchase-request.ts
+import { z as z12 } from "zod";
+var createPurchaseRequest = z12.lazy(() => {
+  return z12.object({
+    destination: z12.string(),
+    dataLimitInGb: z12.number(),
+    startDate: z12.string(),
+    endDate: z12.string(),
+    email: z12.string().optional(),
+    referenceId: z12.string().optional(),
+    networkBrand: z12.string().optional(),
+    startTime: z12.number().optional(),
+    endTime: z12.number().optional()
+  });
+});
+var createPurchaseRequestResponse = z12.lazy(() => {
+  return z12.object({
+    destination: z12.string(),
+    dataLimitInGB: z12.number(),
+    startDate: z12.string(),
+    endDate: z12.string(),
+    email: z12.string().optional(),
+    referenceId: z12.string().optional(),
+    networkBrand: z12.string().optional(),
+    startTime: z12.number().optional(),
+    endTime: z12.number().optional()
+  }).transform((data) => ({
+    destination: data["destination"],
+    dataLimitInGb: data["dataLimitInGB"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    email: data["email"],
+    referenceId: data["referenceId"],
+    networkBrand: data["networkBrand"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+var createPurchaseRequestRequest = z12.lazy(() => {
+  return z12.object({
+    destination: z12.string().nullish(),
+    dataLimitInGb: z12.number().nullish(),
+    startDate: z12.string().nullish(),
+    endDate: z12.string().nullish(),
+    email: z12.string().nullish(),
+    referenceId: z12.string().nullish(),
+    networkBrand: z12.string().nullish(),
+    startTime: z12.number().nullish(),
+    endTime: z12.number().nullish()
+  }).transform((data) => ({
+    destination: data["destination"],
+    dataLimitInGB: data["dataLimitInGb"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    email: data["email"],
+    referenceId: data["referenceId"],
+    networkBrand: data["networkBrand"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+
+// src/services/purchases/models/create-purchase-ok-response.ts
+import { z as z15 } from "zod";
+
+// src/services/purchases/models/create-purchase-ok-response-purchase.ts
+import { z as z13 } from "zod";
+var createPurchaseOkResponsePurchase = z13.lazy(() => {
+  return z13.object({
+    id: z13.string().optional(),
+    packageId: z13.string().optional(),
+    startDate: z13.string().optional(),
+    endDate: z13.string().optional(),
+    createdDate: z13.string().optional(),
+    startTime: z13.number().optional(),
+    endTime: z13.number().optional()
+  });
+});
+var createPurchaseOkResponsePurchaseResponse = z13.lazy(() => {
+  return z13.object({
+    id: z13.string().optional(),
+    packageId: z13.string().optional(),
+    startDate: z13.string().optional(),
+    endDate: z13.string().optional(),
+    createdDate: z13.string().optional(),
+    startTime: z13.number().optional(),
+    endTime: z13.number().optional()
+  }).transform((data) => ({
+    id: data["id"],
+    packageId: data["packageId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+var createPurchaseOkResponsePurchaseRequest = z13.lazy(() => {
+  return z13.object({
+    id: z13.string().nullish(),
+    packageId: z13.string().nullish(),
+    startDate: z13.string().nullish(),
+    endDate: z13.string().nullish(),
+    createdDate: z13.string().nullish(),
+    startTime: z13.number().nullish(),
+    endTime: z13.number().nullish()
+  }).transform((data) => ({
+    id: data["id"],
+    packageId: data["packageId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+
+// src/services/purchases/models/create-purchase-ok-response-profile.ts
+import { z as z14 } from "zod";
+var createPurchaseOkResponseProfile = z14.lazy(() => {
+  return z14.object({
+    iccid: z14.string().min(18).max(22).optional(),
+    activationCode: z14.string().min(1e3).max(8e3).optional()
+  });
+});
+var createPurchaseOkResponseProfileResponse = z14.lazy(() => {
+  return z14.object({
+    iccid: z14.string().min(18).max(22).optional(),
+    activationCode: z14.string().min(1e3).max(8e3).optional()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    activationCode: data["activationCode"]
+  }));
+});
+var createPurchaseOkResponseProfileRequest = z14.lazy(() => {
+  return z14.object({ iccid: z14.string().nullish(), activationCode: z14.string().nullish() }).transform((data) => ({
+    iccid: data["iccid"],
+    activationCode: data["activationCode"]
+  }));
+});
+
+// src/services/purchases/models/create-purchase-ok-response.ts
+var createPurchaseOkResponse = z15.lazy(() => {
+  return z15.object({
+    purchase: createPurchaseOkResponsePurchase.optional(),
+    profile: createPurchaseOkResponseProfile.optional()
+  });
+});
+var createPurchaseOkResponseResponse = z15.lazy(() => {
+  return z15.object({
+    purchase: createPurchaseOkResponsePurchaseResponse.optional(),
+    profile: createPurchaseOkResponseProfileResponse.optional()
+  }).transform((data) => ({
+    purchase: data["purchase"],
+    profile: data["profile"]
+  }));
+});
+var createPurchaseOkResponseRequest = z15.lazy(() => {
+  return z15.object({
+    purchase: createPurchaseOkResponsePurchaseRequest.nullish(),
+    profile: createPurchaseOkResponseProfileRequest.nullish()
+  }).transform((data) => ({
+    purchase: data["purchase"],
+    profile: data["profile"]
+  }));
+});
+
+// src/services/purchases/models/top-up-esim-request.ts
+import { z as z16 } from "zod";
+var topUpEsimRequest = z16.lazy(() => {
+  return z16.object({
+    iccid: z16.string().min(18).max(22),
+    dataLimitInGb: z16.number(),
+    startDate: z16.string(),
+    endDate: z16.string(),
+    email: z16.string().optional(),
+    referenceId: z16.string().optional(),
+    startTime: z16.number().optional(),
+    endTime: z16.number().optional()
+  });
+});
+var topUpEsimRequestResponse = z16.lazy(() => {
+  return z16.object({
+    iccid: z16.string().min(18).max(22),
+    dataLimitInGB: z16.number(),
+    startDate: z16.string(),
+    endDate: z16.string(),
+    email: z16.string().optional(),
+    referenceId: z16.string().optional(),
+    startTime: z16.number().optional(),
+    endTime: z16.number().optional()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    dataLimitInGb: data["dataLimitInGB"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    email: data["email"],
+    referenceId: data["referenceId"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+var topUpEsimRequestRequest = z16.lazy(() => {
+  return z16.object({
+    iccid: z16.string().nullish(),
+    dataLimitInGb: z16.number().nullish(),
+    startDate: z16.string().nullish(),
+    endDate: z16.string().nullish(),
+    email: z16.string().nullish(),
+    referenceId: z16.string().nullish(),
+    startTime: z16.number().nullish(),
+    endTime: z16.number().nullish()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    dataLimitInGB: data["dataLimitInGb"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    email: data["email"],
+    referenceId: data["referenceId"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+
+// src/services/purchases/models/top-up-esim-ok-response.ts
+import { z as z19 } from "zod";
+
+// src/services/purchases/models/top-up-esim-ok-response-purchase.ts
+import { z as z17 } from "zod";
+var topUpEsimOkResponsePurchase = z17.lazy(() => {
+  return z17.object({
+    id: z17.string().optional(),
+    packageId: z17.string().optional(),
+    startDate: z17.string().optional(),
+    endDate: z17.string().optional(),
+    createdDate: z17.string().optional(),
+    startTime: z17.number().optional(),
+    endTime: z17.number().optional()
+  });
+});
+var topUpEsimOkResponsePurchaseResponse = z17.lazy(() => {
+  return z17.object({
+    id: z17.string().optional(),
+    packageId: z17.string().optional(),
+    startDate: z17.string().optional(),
+    endDate: z17.string().optional(),
+    createdDate: z17.string().optional(),
+    startTime: z17.number().optional(),
+    endTime: z17.number().optional()
+  }).transform((data) => ({
+    id: data["id"],
+    packageId: data["packageId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+var topUpEsimOkResponsePurchaseRequest = z17.lazy(() => {
+  return z17.object({
+    id: z17.string().nullish(),
+    packageId: z17.string().nullish(),
+    startDate: z17.string().nullish(),
+    endDate: z17.string().nullish(),
+    createdDate: z17.string().nullish(),
+    startTime: z17.number().nullish(),
+    endTime: z17.number().nullish()
+  }).transform((data) => ({
+    id: data["id"],
+    packageId: data["packageId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    createdDate: data["createdDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+
+// src/services/purchases/models/top-up-esim-ok-response-profile.ts
+import { z as z18 } from "zod";
+var topUpEsimOkResponseProfile = z18.lazy(() => {
+  return z18.object({
+    iccid: z18.string().min(18).max(22).optional()
+  });
+});
+var topUpEsimOkResponseProfileResponse = z18.lazy(() => {
+  return z18.object({
+    iccid: z18.string().min(18).max(22).optional()
+  }).transform((data) => ({
+    iccid: data["iccid"]
+  }));
+});
+var topUpEsimOkResponseProfileRequest = z18.lazy(() => {
+  return z18.object({ iccid: z18.string().nullish() }).transform((data) => ({
+    iccid: data["iccid"]
+  }));
+});
+
+// src/services/purchases/models/top-up-esim-ok-response.ts
+var topUpEsimOkResponse = z19.lazy(() => {
+  return z19.object({
+    purchase: topUpEsimOkResponsePurchase.optional(),
+    profile: topUpEsimOkResponseProfile.optional()
+  });
+});
+var topUpEsimOkResponseResponse = z19.lazy(() => {
+  return z19.object({
+    purchase: topUpEsimOkResponsePurchaseResponse.optional(),
+    profile: topUpEsimOkResponseProfileResponse.optional()
+  }).transform((data) => ({
+    purchase: data["purchase"],
+    profile: data["profile"]
+  }));
+});
+var topUpEsimOkResponseRequest = z19.lazy(() => {
+  return z19.object({
+    purchase: topUpEsimOkResponsePurchaseRequest.nullish(),
+    profile: topUpEsimOkResponseProfileRequest.nullish()
+  }).transform((data) => ({
+    purchase: data["purchase"],
+    profile: data["profile"]
+  }));
+});
+
+// src/services/purchases/models/edit-purchase-request.ts
+import { z as z20 } from "zod";
+var editPurchaseRequest = z20.lazy(() => {
+  return z20.object({
+    purchaseId: z20.string(),
+    startDate: z20.string(),
+    endDate: z20.string(),
+    startTime: z20.number().optional(),
+    endTime: z20.number().optional()
+  });
+});
+var editPurchaseRequestResponse = z20.lazy(() => {
+  return z20.object({
+    purchaseId: z20.string(),
+    startDate: z20.string(),
+    endDate: z20.string(),
+    startTime: z20.number().optional(),
+    endTime: z20.number().optional()
+  }).transform((data) => ({
+    purchaseId: data["purchaseId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+var editPurchaseRequestRequest = z20.lazy(() => {
+  return z20.object({
+    purchaseId: z20.string().nullish(),
+    startDate: z20.string().nullish(),
+    endDate: z20.string().nullish(),
+    startTime: z20.number().nullish(),
+    endTime: z20.number().nullish()
+  }).transform((data) => ({
+    purchaseId: data["purchaseId"],
+    startDate: data["startDate"],
+    endDate: data["endDate"],
+    startTime: data["startTime"],
+    endTime: data["endTime"]
+  }));
+});
+
+// src/services/purchases/models/edit-purchase-ok-response.ts
+import { z as z21 } from "zod";
+var editPurchaseOkResponse = z21.lazy(() => {
+  return z21.object({
+    purchaseId: z21.string().optional(),
+    newStartDate: z21.string().optional(),
+    newEndDate: z21.string().optional(),
+    newStartTime: z21.number().optional(),
+    newEndTime: z21.number().optional()
+  });
+});
+var editPurchaseOkResponseResponse = z21.lazy(() => {
+  return z21.object({
+    purchaseId: z21.string().optional(),
+    newStartDate: z21.string().optional(),
+    newEndDate: z21.string().optional(),
+    newStartTime: z21.number().optional(),
+    newEndTime: z21.number().optional()
+  }).transform((data) => ({
+    purchaseId: data["purchaseId"],
+    newStartDate: data["newStartDate"],
+    newEndDate: data["newEndDate"],
+    newStartTime: data["newStartTime"],
+    newEndTime: data["newEndTime"]
+  }));
+});
+var editPurchaseOkResponseRequest = z21.lazy(() => {
+  return z21.object({
+    purchaseId: z21.string().nullish(),
+    newStartDate: z21.string().nullish(),
+    newEndDate: z21.string().nullish(),
+    newStartTime: z21.number().nullish(),
+    newEndTime: z21.number().nullish()
+  }).transform((data) => ({
+    purchaseId: data["purchaseId"],
+    newStartDate: data["newStartDate"],
+    newEndDate: data["newEndDate"],
+    newStartTime: data["newStartTime"],
+    newEndTime: data["newEndTime"]
+  }));
+});
+
+// src/services/purchases/models/get-purchase-consumption-ok-response.ts
+import { z as z22 } from "zod";
+var getPurchaseConsumptionOkResponse = z22.lazy(() => {
+  return z22.object({
+    dataUsageRemainingInBytes: z22.number().optional(),
+    status: z22.string().optional()
+  });
+});
+var getPurchaseConsumptionOkResponseResponse = z22.lazy(() => {
+  return z22.object({
+    dataUsageRemainingInBytes: z22.number().optional(),
+    status: z22.string().optional()
+  }).transform((data) => ({
+    dataUsageRemainingInBytes: data["dataUsageRemainingInBytes"],
+    status: data["status"]
+  }));
+});
+var getPurchaseConsumptionOkResponseRequest = z22.lazy(() => {
+  return z22.object({ dataUsageRemainingInBytes: z22.number().nullish(), status: z22.string().nullish() }).transform((data) => ({
+    dataUsageRemainingInBytes: data["dataUsageRemainingInBytes"],
+    status: data["status"]
+  }));
+});
+
+// src/services/purchases/purchases.ts
+var PurchasesService = class extends BaseService {
+  /**
+   * This endpoint can be used to list all the successful purchases made between a given interval.
+   * @param {string} [iccid] - ID of the eSIM
+   * @param {string} [afterDate] - Start date of the interval for filtering purchases in the format 'yyyy-MM-dd'
+   * @param {string} [beforeDate] - End date of the interval for filtering purchases in the format 'yyyy-MM-dd'
+   * @param {string} [referenceId] - The referenceId that was provided by the partner during the purchase or topup flow.
+   * @param {string} [afterCursor] - To get the next batch of results, use this parameter. It tells the API where to start fetching data after the last item you received. It helps you avoid repeats and efficiently browse through large sets of data.
+   * @param {number} [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} [after] - Epoch value representing the start of the time interval for filtering purchases
+   * @param {number} [before] - Epoch value representing the end of the time interval for filtering purchases
+   * @returns {Promise<HttpResponse<ListPurchasesOkResponse>>} Successful Response
+   */
+  async listPurchases(params, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/purchases").setRequestSchema(z23.any()).setResponseSchema(listPurchasesOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addQueryParam({
+      key: "iccid",
+      value: params == null ? void 0 : params.iccid
+    }).addQueryParam({
+      key: "afterDate",
+      value: params == null ? void 0 : params.afterDate
+    }).addQueryParam({
+      key: "beforeDate",
+      value: params == null ? void 0 : params.beforeDate
+    }).addQueryParam({
+      key: "referenceId",
+      value: params == null ? void 0 : params.referenceId
+    }).addQueryParam({
+      key: "afterCursor",
+      value: params == null ? void 0 : params.afterCursor
+    }).addQueryParam({
+      key: "limit",
+      value: params == null ? void 0 : params.limit
+    }).addQueryParam({
+      key: "after",
+      value: params == null ? void 0 : params.after
+    }).addQueryParam({
+      key: "before",
+      value: params == null ? void 0 : params.before
+    }).build();
+    return this.client.call(request);
+  }
+  /**
+   * This endpoint is used to purchase a new eSIM by providing the package details.
+   * @returns {Promise<HttpResponse<CreatePurchaseOkResponse>>} Successful Response
+   */
+  async createPurchase(body, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("POST").setPath("/purchases").setRequestSchema(createPurchaseRequestRequest).setResponseSchema(createPurchaseOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addHeaderParam({ key: "Content-Type", value: "application/json" }).addBody(body).build();
+    return this.client.call(request);
+  }
+  /**
+   * This endpoint is used to top-up an eSIM with the previously associated destination by providing an existing ICCID and the package details. The top-up is not feasible for eSIMs in "DELETED" or "ERROR" state.
+   * @returns {Promise<HttpResponse<TopUpEsimOkResponse>>} Successful Response
+   */
+  async topUpEsim(body, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("POST").setPath("/purchases/topup").setRequestSchema(topUpEsimRequestRequest).setResponseSchema(topUpEsimOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addHeaderParam({ key: "Content-Type", value: "application/json" }).addBody(body).build();
+    return this.client.call(request);
+  }
+  /**
+   * This endpoint allows you to modify the dates of an existing package with a future activation start time. Editing can only be performed for packages that have not been activated, and it cannot change the package size. The modification must not change the package duration category to ensure pricing consistency.
+   * @returns {Promise<HttpResponse<EditPurchaseOkResponse>>} Successful Response
+   */
+  async editPurchase(body, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("POST").setPath("/purchases/edit").setRequestSchema(editPurchaseRequestRequest).setResponseSchema(editPurchaseOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addHeaderParam({ key: "Content-Type", value: "application/json" }).addBody(body).build();
+    return this.client.call(request);
+  }
+  /**
+   * 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
+   * @returns {Promise<HttpResponse<GetPurchaseConsumptionOkResponse>>} Successful Response
+   */
+  async getPurchaseConsumption(purchaseId, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/purchases/{purchaseId}/consumption").setRequestSchema(z23.any()).setResponseSchema(getPurchaseConsumptionOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addPathParam({
+      key: "purchaseId",
+      value: purchaseId
+    }).build();
+    return this.client.call(request);
+  }
+};
+
+// src/services/e-sim/e-sim.ts
+import { z as z33 } from "zod";
+
+// src/services/e-sim/models/get-esim-ok-response.ts
+import { z as z25 } from "zod";
+
+// src/services/e-sim/models/get-esim-ok-response-esim.ts
+import { z as z24 } from "zod";
+var getEsimOkResponseEsim = z24.lazy(() => {
+  return z24.object({
+    iccid: z24.string().min(18).max(22).optional(),
+    smdpAddress: z24.string().optional(),
+    manualActivationCode: z24.string().optional(),
+    status: z24.string().optional()
+  });
+});
+var getEsimOkResponseEsimResponse = z24.lazy(() => {
+  return z24.object({
+    iccid: z24.string().min(18).max(22).optional(),
+    smdpAddress: z24.string().optional(),
+    manualActivationCode: z24.string().optional(),
+    status: z24.string().optional()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    smdpAddress: data["smdpAddress"],
+    manualActivationCode: data["manualActivationCode"],
+    status: data["status"]
+  }));
+});
+var getEsimOkResponseEsimRequest = z24.lazy(() => {
+  return z24.object({
+    iccid: z24.string().nullish(),
+    smdpAddress: z24.string().nullish(),
+    manualActivationCode: z24.string().nullish(),
+    status: z24.string().nullish()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    smdpAddress: data["smdpAddress"],
+    manualActivationCode: data["manualActivationCode"],
+    status: data["status"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-ok-response.ts
+var getEsimOkResponse = z25.lazy(() => {
+  return z25.object({
+    esim: getEsimOkResponseEsim.optional()
+  });
+});
+var getEsimOkResponseResponse = z25.lazy(() => {
+  return z25.object({
+    esim: getEsimOkResponseEsimResponse.optional()
+  }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+var getEsimOkResponseRequest = z25.lazy(() => {
+  return z25.object({ esim: getEsimOkResponseEsimRequest.nullish() }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-device-ok-response.ts
+import { z as z27 } from "zod";
+
+// src/services/e-sim/models/device.ts
+import { z as z26 } from "zod";
+var device = z26.lazy(() => {
+  return z26.object({
+    oem: z26.string().optional(),
+    hardwareName: z26.string().optional(),
+    hardwareModel: z26.string().optional(),
+    eid: z26.string().optional()
+  });
+});
+var deviceResponse = z26.lazy(() => {
+  return z26.object({
+    oem: z26.string().optional(),
+    hardwareName: z26.string().optional(),
+    hardwareModel: z26.string().optional(),
+    eid: z26.string().optional()
+  }).transform((data) => ({
+    oem: data["oem"],
+    hardwareName: data["hardwareName"],
+    hardwareModel: data["hardwareModel"],
+    eid: data["eid"]
+  }));
+});
+var deviceRequest = z26.lazy(() => {
+  return z26.object({
+    oem: z26.string().nullish(),
+    hardwareName: z26.string().nullish(),
+    hardwareModel: z26.string().nullish(),
+    eid: z26.string().nullish()
+  }).transform((data) => ({
+    oem: data["oem"],
+    hardwareName: data["hardwareName"],
+    hardwareModel: data["hardwareModel"],
+    eid: data["eid"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-device-ok-response.ts
+var getEsimDeviceOkResponse = z27.lazy(() => {
+  return z27.object({
+    device: device.optional()
+  });
+});
+var getEsimDeviceOkResponseResponse = z27.lazy(() => {
+  return z27.object({
+    device: deviceResponse.optional()
+  }).transform((data) => ({
+    device: data["device"]
+  }));
+});
+var getEsimDeviceOkResponseRequest = z27.lazy(() => {
+  return z27.object({ device: deviceRequest.nullish() }).transform((data) => ({
+    device: data["device"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-history-ok-response.ts
+import { z as z30 } from "zod";
+
+// src/services/e-sim/models/get-esim-history-ok-response-esim.ts
+import { z as z29 } from "zod";
+
+// src/services/e-sim/models/history.ts
+import { z as z28 } from "zod";
+var history = z28.lazy(() => {
+  return z28.object({
+    status: z28.string().optional(),
+    statusDate: z28.string().optional(),
+    date: z28.number().optional()
+  });
+});
+var historyResponse = z28.lazy(() => {
+  return z28.object({
+    status: z28.string().optional(),
+    statusDate: z28.string().optional(),
+    date: z28.number().optional()
+  }).transform((data) => ({
+    status: data["status"],
+    statusDate: data["statusDate"],
+    date: data["date"]
+  }));
+});
+var historyRequest = z28.lazy(() => {
+  return z28.object({ status: z28.string().nullish(), statusDate: z28.string().nullish(), date: z28.number().nullish() }).transform((data) => ({
+    status: data["status"],
+    statusDate: data["statusDate"],
+    date: data["date"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-history-ok-response-esim.ts
+var getEsimHistoryOkResponseEsim = z29.lazy(() => {
+  return z29.object({
+    iccid: z29.string().min(18).max(22).optional(),
+    history: z29.array(history).optional()
+  });
+});
+var getEsimHistoryOkResponseEsimResponse = z29.lazy(() => {
+  return z29.object({
+    iccid: z29.string().min(18).max(22).optional(),
+    history: z29.array(historyResponse).optional()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    history: data["history"]
+  }));
+});
+var getEsimHistoryOkResponseEsimRequest = z29.lazy(() => {
+  return z29.object({ iccid: z29.string().nullish(), history: z29.array(historyRequest).nullish() }).transform((data) => ({
+    iccid: data["iccid"],
+    history: data["history"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-history-ok-response.ts
+var getEsimHistoryOkResponse = z30.lazy(() => {
+  return z30.object({
+    esim: getEsimHistoryOkResponseEsim.optional()
+  });
+});
+var getEsimHistoryOkResponseResponse = z30.lazy(() => {
+  return z30.object({
+    esim: getEsimHistoryOkResponseEsimResponse.optional()
+  }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+var getEsimHistoryOkResponseRequest = z30.lazy(() => {
+  return z30.object({ esim: getEsimHistoryOkResponseEsimRequest.nullish() }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-mac-ok-response.ts
+import { z as z32 } from "zod";
+
+// src/services/e-sim/models/get-esim-mac-ok-response-esim.ts
+import { z as z31 } from "zod";
+var getEsimMacOkResponseEsim = z31.lazy(() => {
+  return z31.object({
+    iccid: z31.string().min(18).max(22).optional(),
+    smdpAddress: z31.string().optional(),
+    manualActivationCode: z31.string().optional()
+  });
+});
+var getEsimMacOkResponseEsimResponse = z31.lazy(() => {
+  return z31.object({
+    iccid: z31.string().min(18).max(22).optional(),
+    smdpAddress: z31.string().optional(),
+    manualActivationCode: z31.string().optional()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    smdpAddress: data["smdpAddress"],
+    manualActivationCode: data["manualActivationCode"]
+  }));
+});
+var getEsimMacOkResponseEsimRequest = z31.lazy(() => {
+  return z31.object({
+    iccid: z31.string().nullish(),
+    smdpAddress: z31.string().nullish(),
+    manualActivationCode: z31.string().nullish()
+  }).transform((data) => ({
+    iccid: data["iccid"],
+    smdpAddress: data["smdpAddress"],
+    manualActivationCode: data["manualActivationCode"]
+  }));
+});
+
+// src/services/e-sim/models/get-esim-mac-ok-response.ts
+var getEsimMacOkResponse = z32.lazy(() => {
+  return z32.object({
+    esim: getEsimMacOkResponseEsim.optional()
+  });
+});
+var getEsimMacOkResponseResponse = z32.lazy(() => {
+  return z32.object({
+    esim: getEsimMacOkResponseEsimResponse.optional()
+  }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+var getEsimMacOkResponseRequest = z32.lazy(() => {
+  return z32.object({ esim: getEsimMacOkResponseEsimRequest.nullish() }).transform((data) => ({
+    esim: data["esim"]
+  }));
+});
+
+// src/services/e-sim/e-sim.ts
+var ESimService = class extends BaseService {
+  /**
+   * Get eSIM Status
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimOkResponse>>} Successful Response
+   */
+  async getEsim(params, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/esim").setRequestSchema(z33.any()).setResponseSchema(getEsimOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addQueryParam({
+      key: "iccid",
+      value: params == null ? void 0 : params.iccid
+    }).build();
+    return this.client.call(request);
+  }
+  /**
+   * Get eSIM Device
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimDeviceOkResponse>>} Successful Response
+   */
+  async getEsimDevice(iccid, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/esim/{iccid}/device").setRequestSchema(z33.any()).setResponseSchema(getEsimDeviceOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addPathParam({
+      key: "iccid",
+      value: iccid
+    }).build();
+    return this.client.call(request);
+  }
+  /**
+   * Get eSIM History
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimHistoryOkResponse>>} Successful Response
+   */
+  async getEsimHistory(iccid, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/esim/{iccid}/history").setRequestSchema(z33.any()).setResponseSchema(getEsimHistoryOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addPathParam({
+      key: "iccid",
+      value: iccid
+    }).build();
+    return this.client.call(request);
+  }
+  /**
+   * Get eSIM MAC
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimMacOkResponse>>} Successful Response
+   */
+  async getEsimMac(iccid, requestConfig) {
+    const request = new RequestBuilder().setConfig(this.config).setBaseUrl(this.config).setMethod("GET").setPath("/esim/{iccid}/mac").setRequestSchema(z33.any()).setResponseSchema(getEsimMacOkResponseResponse).setRequestContentType("json" /* Json */).setResponseContentType("json" /* Json */).setRetryAttempts(this.config, requestConfig).setRetryDelayMs(this.config, requestConfig).setResponseValidation(this.config, requestConfig).addPathParam({
+      key: "iccid",
+      value: iccid
+    }).build();
+    return this.client.call(request);
+  }
+};
+
+// src/index.ts
+var Celitech = class {
+  constructor(config) {
+    this.config = config;
+    const baseUrl = config.environment || config.baseUrl || "https://api.celitech.net/v1" /* DEFAULT */;
+    this.config = {
+      ...config,
+      baseUrl
+    };
+    this.destinations = new DestinationsService(this.config);
+    this.packages = new PackagesService(this.config);
+    this.purchases = new PurchasesService(this.config);
+    this.eSim = new ESimService(this.config);
+  }
+  set baseUrl(baseUrl) {
+    this.destinations.baseUrl = baseUrl;
+    this.packages.baseUrl = baseUrl;
+    this.purchases.baseUrl = baseUrl;
+    this.eSim.baseUrl = baseUrl;
+  }
+  set environment(environment) {
+    this.destinations.baseUrl = environment;
+    this.packages.baseUrl = environment;
+    this.purchases.baseUrl = environment;
+    this.eSim.baseUrl = environment;
+  }
+  set timeout(timeout) {
+    this.destinations.timeout = timeout;
+    this.packages.timeout = timeout;
+    this.purchases.timeout = timeout;
+    this.eSim.timeout = timeout;
+  }
+  set clientId(clientId) {
+    this.destinations.clientId = clientId;
+    this.packages.clientId = clientId;
+    this.purchases.clientId = clientId;
+    this.eSim.clientId = clientId;
+  }
+  set clientSecret(clientSecret) {
+    this.destinations.clientSecret = clientSecret;
+    this.packages.clientSecret = clientSecret;
+    this.purchases.clientSecret = clientSecret;
+    this.eSim.clientSecret = clientSecret;
+  }
+};
+export {
+  Celitech,
+  DestinationsService,
+  ESimService,
+  PackagesService,
+  PurchasesService
+};