@ariary/notification 4.1.0 → 4.2.0

package/dist/index.mjs

@@ -1,38 +1,3 @@
-// ../common/http.ts
-async function request(verb, endpoint, options, config) {
-  if (!config) throw new Error("Ariari package not configured.");
-  const url = `${config.baseUrl || "https://api.ariari.mg"}${endpoint}`;
-  const headers = { "Content-Type": "application/json" };
-  if (!options.public) {
-    headers["x-secret"] = config.secret;
-  }
-  const fetchOptions = { method: verb, headers };
-  if ("body" in options && options.body) {
-    fetchOptions.body = JSON.stringify(options.body);
-  }
-  try {
-    const response = await fetch(url, fetchOptions);
-    const data = await response.json();
-    if (!response.ok) {
-      const message = data?.message || "Unknown error";
-      throw new Error(`[${response.status}] ${message}`);
-    }
-    return data;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-    throw new Error("Network error");
-  }
-}
-var createRequester = (config) => ({
-  get: (url, data = {}) => request("GET", url, data, config),
-  post: (url, data = {}) => request("POST", url, data, config),
-  patch: (url, data = {}) => request("PATCH", url, data, config),
-  put: (url, data = {}) => request("PUT", url, data, config),
-  delete: (url, data = {}) => request("DELETE", url, data, config)
-});
-
 // ../common/phone.ts
 var normalizePhoneNumber = (phone) => {
   let normalized = phone.replace(/\D/g, "");
@@ -40,6 +5,317 @@ var normalizePhoneNumber = (phone) => {
   return normalized;
 };
 
+// ../common/gen/runtime.ts
+var BASE_PATH = "http://localhost".replace(/\/+$/, "");
+var Configuration = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration();
+var _BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.fetchApi = async (url, init) => {
+      let fetchParams = { url, init };
+      for (const middleware of this.middleware) {
+        if (middleware.pre) {
+          fetchParams = await middleware.pre({
+            fetch: this.fetchApi,
+            ...fetchParams
+          }) || fetchParams;
+        }
+      }
+      let response = void 0;
+      try {
+        response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+      } catch (e) {
+        for (const middleware of this.middleware) {
+          if (middleware.onError) {
+            response = await middleware.onError({
+              fetch: this.fetchApi,
+              url: fetchParams.url,
+              init: fetchParams.init,
+              error: e,
+              response: response ? response.clone() : void 0
+            }) || response;
+          }
+        }
+        if (response === void 0) {
+          if (e instanceof Error) {
+            throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+          } else {
+            throw e;
+          }
+        }
+      }
+      for (const middleware of this.middleware) {
+        if (middleware.post) {
+          response = await middleware.post({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            response: response.clone()
+          }) || response;
+        }
+      }
+      return response;
+    };
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+_BaseAPI.jsonRegex = new RegExp("^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$", "i");
+var BaseAPI = _BaseAPI;
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+    this.name = "ResponseError";
+  }
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    this.name = "FetchError";
+  }
+};
+var RequiredError = class extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+    this.name = "RequiredError";
+  }
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+var JSONApiResponse = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+};
+
+// ../common/gen/models/SmsMessage.ts
+function SmsMessageToJSON(json) {
+  return SmsMessageToJSONTyped(json, false);
+}
+function SmsMessageToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "phones": value["phones"],
+    "message": value["message"]
+  };
+}
+
+// ../common/gen/models/BulkSms.ts
+function BulkSmsToJSON(json) {
+  return BulkSmsToJSONTyped(json, false);
+}
+function BulkSmsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "messages": value["messages"].map(SmsMessageToJSON),
+    "scheduledAt": value["scheduledAt"]
+  };
+}
+
+// ../common/gen/models/EstimateMessage.ts
+function EstimateMessageToJSON(json) {
+  return EstimateMessageToJSONTyped(json, false);
+}
+function EstimateMessageToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "text": value["text"],
+    "repeat": value["repeat"]
+  };
+}
+
+// ../common/gen/models/EstimateSms.ts
+function EstimateSmsToJSON(json) {
+  return EstimateSmsToJSONTyped(json, false);
+}
+function EstimateSmsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "messages": value["messages"].map(EstimateMessageToJSON)
+  };
+}
+
+// ../common/gen/models/EstimateSmsResponse.ts
+function EstimateSmsResponseFromJSON(json) {
+  return EstimateSmsResponseFromJSONTyped(json, false);
+}
+function EstimateSmsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "sms": json["sms"],
+    "credit": json["credit"]
+  };
+}
+
 // ../common/gen/models/NotifTaskStatus.ts
 function NotifTaskStatusFromJSON(json) {
   return NotifTaskStatusFromJSONTyped(json, false);
@@ -56,6 +332,64 @@ function NotifTaskStatusFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 
+// ../common/gen/models/SmsStatus.ts
+function SmsStatusFromJSON(json) {
+  return SmsStatusFromJSONTyped(json, false);
+}
+function SmsStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../common/gen/models/SmsDetail.ts
+function SmsDetailFromJSON(json) {
+  return SmsDetailFromJSONTyped(json, false);
+}
+function SmsDetailFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "smsId": json["smsId"],
+    "phone": json["phone"],
+    "message": json["message"],
+    "status": SmsStatusFromJSON(json["status"]),
+    "retryCount": json["retryCount"]
+  };
+}
+
+// ../common/gen/models/NotifTaskWithSms.ts
+function NotifTaskWithSmsFromJSON(json) {
+  return NotifTaskWithSmsFromJSONTyped(json, false);
+}
+function NotifTaskWithSmsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "taskId": json["taskId"],
+    "status": NotifTaskStatusFromJSON(json["status"]),
+    "statusPage": NotifTaskStatusFromJSON(json["statusPage"]),
+    "createdAt": new Date(json["createdAt"]),
+    "scheduledAt": json["scheduledAt"] == null ? void 0 : new Date(json["scheduledAt"]),
+    "sms": json["sms"].map(SmsDetailFromJSON)
+  };
+}
+
+// ../common/gen/models/PaginationParams.ts
+function PaginationParamsFromJSON(json) {
+  return PaginationParamsFromJSONTyped(json, false);
+}
+function PaginationParamsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "from": json["from"] == null ? void 0 : json["from"],
+    "count": json["count"] == null ? void 0 : json["count"],
+    "order": json["order"] == null ? void 0 : json["order"]
+  };
+}
+
 // ../common/gen/models/ResponseNotifTask.ts
 function ResponseNotifTaskFromJSON(json) {
   return ResponseNotifTaskFromJSONTyped(json, false);
@@ -73,31 +407,401 @@ function ResponseNotifTaskFromJSONTyped(json, ignoreDiscriminator) {
   };
 }
 
-// ../common/gen/models/SmsStatus.ts
-function SmsStatusFromJSON(json) {
-  return SmsStatusFromJSONTyped(json, false);
+// ../common/gen/models/PaginatedNotifTaskResponse.ts
+function PaginatedNotifTaskResponseFromJSON(json) {
+  return PaginatedNotifTaskResponseFromJSONTyped(json, false);
 }
-function SmsStatusFromJSONTyped(json, ignoreDiscriminator) {
-  return json;
+function PaginatedNotifTaskResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "tasks": json["tasks"].map(ResponseNotifTaskFromJSON),
+    "next": PaginationParamsFromJSON(json["next"]),
+    "prev": json["prev"] == null ? void 0 : PaginationParamsFromJSON(json["prev"])
+  };
 }
 
-// ../common/gen/models/SmsDetail.ts
-function SmsDetailFromJSON(json) {
-  return SmsDetailFromJSONTyped(json, false);
+// ../common/gen/models/ResponseSms.ts
+function ResponseSmsFromJSON(json) {
+  return ResponseSmsFromJSONTyped(json, false);
 }
-function SmsDetailFromJSONTyped(json, ignoreDiscriminator) {
+function ResponseSmsFromJSONTyped(json, ignoreDiscriminator) {
   if (json == null) {
     return json;
   }
   return {
-    "smsId": json["smsId"],
+    "id": json["_id"],
     "phone": json["phone"],
-    "message": json["message"],
     "status": SmsStatusFromJSON(json["status"]),
-    "retryCount": json["retryCount"]
+    "createdAt": new Date(json["createdAt"]),
+    "simItem": json["simItem"] == null ? void 0 : json["simItem"]
   };
 }
 
+// ../common/gen/apis/NotifTaskApi.ts
+var NotifTaskApi = class extends BaseAPI {
+  /**
+   * Creates request options for notifTaskFindAll without sending the request
+   */
+  async notifTaskFindAllRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling notifTaskFindAll().'
+      );
+    }
+    if (requestParameters["from"] == null) {
+      throw new RequiredError(
+        "from",
+        'Required parameter "from" was null or undefined when calling notifTaskFindAll().'
+      );
+    }
+    if (requestParameters["count"] == null) {
+      throw new RequiredError(
+        "count",
+        'Required parameter "count" was null or undefined when calling notifTaskFindAll().'
+      );
+    }
+    if (requestParameters["order"] == null) {
+      throw new RequiredError(
+        "order",
+        'Required parameter "order" was null or undefined when calling notifTaskFindAll().'
+      );
+    }
+    if (requestParameters["projectId"] == null) {
+      throw new RequiredError(
+        "projectId",
+        'Required parameter "projectId" was null or undefined when calling notifTaskFindAll().'
+      );
+    }
+    const queryParameters = {};
+    if (requestParameters["from"] != null) {
+      queryParameters["from"] = requestParameters["from"];
+    }
+    if (requestParameters["count"] != null) {
+      queryParameters["count"] = requestParameters["count"];
+    }
+    if (requestParameters["order"] != null) {
+      queryParameters["order"] = requestParameters["order"];
+    }
+    if (requestParameters["projectId"] != null) {
+      queryParameters["projectId"] = requestParameters["projectId"];
+    }
+    const headerParameters = {};
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/notif-task`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Récupérer les tâches avec pagination
+   */
+  async notifTaskFindAllRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.notifTaskFindAllRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PaginatedNotifTaskResponseFromJSON(jsonValue));
+  }
+  /**
+   * Récupérer les tâches avec pagination
+   */
+  async notifTaskFindAll(requestParameters, initOverrides) {
+    const response = await this.notifTaskFindAllRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for notifTaskFindAllWithSms without sending the request
+   */
+  async notifTaskFindAllWithSmsRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling notifTaskFindAllWithSms().'
+      );
+    }
+    if (requestParameters["projectId"] == null) {
+      throw new RequiredError(
+        "projectId",
+        'Required parameter "projectId" was null or undefined when calling notifTaskFindAllWithSms().'
+      );
+    }
+    if (requestParameters["days"] == null) {
+      throw new RequiredError(
+        "days",
+        'Required parameter "days" was null or undefined when calling notifTaskFindAllWithSms().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/notif-task/history/{projectId}/{days}`;
+    urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters["projectId"])));
+    urlPath = urlPath.replace(`{${"days"}}`, encodeURIComponent(String(requestParameters["days"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Récupérer toutes les tâches avec SMS détaillés sur N jours pour un projet
+   */
+  async notifTaskFindAllWithSmsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.notifTaskFindAllWithSmsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(NotifTaskWithSmsFromJSON));
+  }
+  /**
+   * Récupérer toutes les tâches avec SMS détaillés sur N jours pour un projet
+   */
+  async notifTaskFindAllWithSms(requestParameters, initOverrides) {
+    const response = await this.notifTaskFindAllWithSmsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for notifTaskFindOne without sending the request
+   */
+  async notifTaskFindOneRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling notifTaskFindOne().'
+      );
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling notifTaskFindOne().'
+      );
+    }
+    if (requestParameters["details"] == null) {
+      throw new RequiredError(
+        "details",
+        'Required parameter "details" was null or undefined when calling notifTaskFindOne().'
+      );
+    }
+    const queryParameters = {};
+    if (requestParameters["details"] != null) {
+      queryParameters["details"] = requestParameters["details"];
+    }
+    const headerParameters = {};
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/notif-task/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Récupérer une tâche par ID, avec SMS optionnels via ?details=limit,page
+   */
+  async notifTaskFindOneRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.notifTaskFindOneRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => NotifTaskWithSmsFromJSON(jsonValue));
+  }
+  /**
+   * Récupérer une tâche par ID, avec SMS optionnels via ?details=limit,page
+   */
+  async notifTaskFindOne(requestParameters, initOverrides) {
+    const response = await this.notifTaskFindOneRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// ../common/gen/apis/SmsApi.ts
+var SmsApi = class extends BaseAPI {
+  /**
+   * Creates request options for smsEstimate without sending the request
+   */
+  async smsEstimateRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling smsEstimate().'
+      );
+    }
+    if (requestParameters["estimateSms"] == null) {
+      throw new RequiredError(
+        "estimateSms",
+        'Required parameter "estimateSms" was null or undefined when calling smsEstimate().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/sms/estimate`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: EstimateSmsToJSON(requestParameters["estimateSms"])
+    };
+  }
+  /**
+   * Estimate SMS credit consumption for a list of messages
+   */
+  async smsEstimateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.smsEstimateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => EstimateSmsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Estimate SMS credit consumption for a list of messages
+   */
+  async smsEstimate(requestParameters, initOverrides) {
+    const response = await this.smsEstimateRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for smsFindAll without sending the request
+   */
+  async smsFindAllRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling smsFindAll().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/sms`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Récupérer l\'historique des SMS de l\'application
+   */
+  async smsFindAllRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.smsFindAllRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(ResponseSmsFromJSON));
+  }
+  /**
+   * Récupérer l\'historique des SMS de l\'application
+   */
+  async smsFindAll(requestParameters, initOverrides) {
+    const response = await this.smsFindAllRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for smsFindOne without sending the request
+   */
+  async smsFindOneRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling smsFindOne().'
+      );
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling smsFindOne().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/sms/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Récupérer un SMS par ID pour l\'application
+   */
+  async smsFindOneRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.smsFindOneRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ResponseSmsFromJSON(jsonValue));
+  }
+  /**
+   * Récupérer un SMS par ID pour l\'application
+   */
+  async smsFindOne(requestParameters, initOverrides) {
+    const response = await this.smsFindOneRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for smsSendBulkSms without sending the request
+   */
+  async smsSendBulkSmsRequestOpts(requestParameters) {
+    if (requestParameters["xSecret"] == null) {
+      throw new RequiredError(
+        "xSecret",
+        'Required parameter "xSecret" was null or undefined when calling smsSendBulkSms().'
+      );
+    }
+    if (requestParameters["bulkSms"] == null) {
+      throw new RequiredError(
+        "bulkSms",
+        'Required parameter "bulkSms" was null or undefined when calling smsSendBulkSms().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xSecret"] != null) {
+      headerParameters["x-secret"] = String(requestParameters["xSecret"]);
+    }
+    let urlPath = `/api/sms/bulk`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: BulkSmsToJSON(requestParameters["bulkSms"])
+    };
+  }
+  /**
+   * Envoyer des messages différents à différents groupes de destinataires
+   */
+  async smsSendBulkSmsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.smsSendBulkSmsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ResponseNotifTaskFromJSON(jsonValue));
+  }
+  /**
+   * Envoyer des messages différents à différents groupes de destinataires
+   */
+  async smsSendBulkSms(requestParameters, initOverrides) {
+    const response = await this.smsSendBulkSmsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
 // src/types/index.ts
 var SmsStatus = /* @__PURE__ */ ((SmsStatus2) => {
   SmsStatus2["SCHEDULED"] = "SCHEDULED";
@@ -120,61 +824,54 @@ var parseSchedule = (input) => {
   }
   return input;
 };
-var parseTaskResponse = (raw) => {
-  const task = {
-    ...ResponseNotifTaskFromJSON(raw.task),
-    ...raw.task.scheduledAt != null && { scheduledAt: new Date(raw.task.scheduledAt) }
-  };
-  return {
-    task,
-    sms: Array.isArray(raw.sms) ? raw.sms.map(SmsDetailFromJSON) : [],
-    total: raw.total ?? 0
-  };
+var normalizeTaskResponse = (json) => {
+  const t = json.task ?? json;
+  return { taskId: t._id ?? t.taskId, status: t.status, statusPage: t.statusPage, createdAt: t.createdAt, scheduledAt: t.scheduledAt, sms: json.sms ?? [] };
 };
 var instances = {};
 var Task = class {
-  constructor(id, requester) {
+  constructor(id, api, secret) {
     this.id = id;
-    this._requester = requester;
+    this._api = api;
+    this._secret = secret;
   }
   async status(count, page) {
-    if (count === void 0) {
-      const res2 = await this._requester.get(`/api/notif-task/${this.id}`);
-      return parseTaskResponse(res2);
-    }
-    const details = `${count},${page || 1}`;
-    const res = await this._requester.get(`/api/notif-task/${this.id}?details=${details}`);
-    return parseTaskResponse(res);
+    const details = count !== void 0 ? `${count},${page || 1}` : "";
+    const raw = await this._api.notifTaskFindOneRaw({ xSecret: this._secret, id: this.id, details });
+    const json = await raw.raw.json();
+    return NotifTaskWithSmsFromJSON(normalizeTaskResponse(json));
   }
   // All SMS at once
   async fullStatus() {
-    const res = await this._requester.get(`/api/notif-task/${this.id}?details=-1`);
-    return parseTaskResponse(res);
+    const raw = await this._api.notifTaskFindOneRaw({ xSecret: this._secret, id: this.id, details: "-1" });
+    const json = await raw.raw.json();
+    return NotifTaskWithSmsFromJSON(normalizeTaskResponse(json));
   }
 };
 var _Ariari = class _Ariari {
-  constructor({ name = "main", ...config }) {
+  constructor({ name = "main", secret, baseUrl }) {
     this.send = async (...args) => {
       const hasSchedule = typeof args[0] === "string";
       const scheduledAt = hasSchedule ? parseSchedule(args[0]) : void 0;
       const data = hasSchedule ? args.slice(1) : args;
-      const body = {
+      const bulkSms = {
         messages: data.map((item) => ({
           phones: (Array.isArray(item.phone) ? item.phone : [item.phone]).map(normalizePhoneNumber),
           message: item.message
         })),
         ...scheduledAt && { scheduledAt }
       };
-      const response = await this._requester.post("/api/sms/bulk", { body });
-      const task = ResponseNotifTaskFromJSON(response);
-      return new Task(task.id, this._requester);
+      const task = await this._smsApi.smsSendBulkSms({ xSecret: this._secret, bulkSms });
+      return new Task(task.id, this._notifTaskApi, this._secret);
     };
-    this.getTask = (taskId) => new Task(taskId, this._requester);
+    this.getTask = (taskId) => new Task(taskId, this._notifTaskApi, this._secret);
     this.estimate = async (...messages) => {
-      return this._requester.post("/api/sms/estimate", { body: { messages } });
+      return this._smsApi.smsEstimate({ xSecret: this._secret, estimateSms: { messages } });
     };
-    this._config = config;
-    this._requester = createRequester(config);
+    this._secret = secret;
+    const configuration = new Configuration({ basePath: baseUrl || "https://api.ariari.mg" });
+    this._smsApi = new SmsApi(configuration);
+    this._notifTaskApi = new NotifTaskApi(configuration);
     instances[name] = this;
   }
 };