@envsync-cloud/envsync-ts-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1163 @@
+// src/core/BaseHttpRequest.ts
+var BaseHttpRequest = class {
+  constructor(config) {
+    this.config = config;
+  }
+};
+
+// src/core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  #isResolved;
+  #isRejected;
+  #isCancelled;
+  #cancelHandlers;
+  #promise;
+  #resolve;
+  #reject;
+  constructor(executor) {
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise((resolve2, reject) => {
+      this.#resolve = resolve2;
+      this.#reject = reject;
+      const onResolve = (value) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isResolved = true;
+        if (this.#resolve) this.#resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#isRejected = true;
+        if (this.#reject) this.#reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+          return;
+        }
+        this.#cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this.#isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this.#isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this.#isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.#promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.#promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.#promise.finally(onFinally);
+  }
+  cancel() {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+      return;
+    }
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.#cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.#cancelHandlers.length = 0;
+    if (this.#reject) this.#reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this.#isCancelled;
+  }
+};
+
+// src/core/request.ts
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// src/core/FetchHttpRequest.ts
+var FetchHttpRequest = class extends BaseHttpRequest {
+  constructor(config) {
+    super(config);
+  }
+  /**
+   * Request method
+   * @param options The request options from the service
+   * @returns CancelablePromise<T>
+   * @throws ApiError
+   */
+  request(options) {
+    return request(this.config, options);
+  }
+};
+
+// src/services/ApplicationsService.ts
+var ApplicationsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get All Applications
+   * Retrieve all applications for the organization
+   * @returns GetAppsResponse Applications retrieved successfully
+   * @throws ApiError
+   */
+  getApps() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/app",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Application
+   * Create a new application
+   * @param requestBody
+   * @returns CreateAppResponse Application created successfully
+   * @throws ApiError
+   */
+  createApp(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/app",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Application
+   * Retrieve a specific application by ID
+   * @param id
+   * @returns GetAppResponse Application retrieved successfully
+   * @throws ApiError
+   */
+  getApp(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/app/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Application
+   * Update an existing application
+   * @param id
+   * @param requestBody
+   * @returns UpdateAppResponse Application updated successfully
+   * @throws ApiError
+   */
+  updateApp(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/app/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Application
+   * Delete an existing application
+   * @param id
+   * @returns DeleteAppResponse Application deleted successfully
+   * @throws ApiError
+   */
+  deleteApp(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/app/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/AuditLogsService.ts
+var AuditLogsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Audit Logs
+   * Retrieve audit logs for the organization with pagination
+   * @param page
+   * @param perPage
+   * @returns GetAuditLogsResponse Audit logs retrieved successfully
+   * @throws ApiError
+   */
+  getAuditLogs(page = 1, perPage = 20) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/audit_log",
+      query: {
+        "page": page,
+        "per_page": perPage
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/AuthenticationService.ts
+var AuthenticationService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Current User
+   * Retrieve the current authenticated user's information and their organization details
+   * @returns WhoAmIResponse User information retrieved successfully
+   * @throws ApiError
+   */
+  whoami() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/auth/me",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/EnvironmentTypesService.ts
+var EnvironmentTypesService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Environment Types
+   * Retrieve all environment types for the organization
+   * @returns EnvTypesResponse Environment types retrieved successfully
+   * @throws ApiError
+   */
+  getEnvTypes() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/env_type",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Environment Type
+   * Create a new environment type
+   * @param requestBody
+   * @returns EnvTypeResponse Environment type created successfully
+   * @throws ApiError
+   */
+  createEnvType(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env_type",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Environment Type
+   * Retrieve a specific environment type
+   * @param id
+   * @returns EnvTypeResponse Environment type retrieved successfully
+   * @throws ApiError
+   */
+  getEnvType(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Environment Type
+   * Update an existing environment type
+   * @param id
+   * @param requestBody
+   * @returns EnvTypeResponse Environment type updated successfully
+   * @throws ApiError
+   */
+  updateEnvType(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Environment Type
+   * Delete an existing environment type
+   * @param id
+   * @returns DeleteEnvTypeRequest Environment type deleted successfully
+   * @throws ApiError
+   */
+  deleteEnvType(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/EnvironmentVariablesService.ts
+var EnvironmentVariablesService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Environment Variables
+   * Retrieve all environment variables for an application and environment type
+   * @param requestBody
+   * @returns EnvsResponse Environment variables retrieved successfully
+   * @throws ApiError
+   */
+  getEnvs(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Environment Variable
+   * Delete an existing environment variable
+   * @param requestBody
+   * @returns DeleteEnvRequest Environment variable deleted successfully
+   * @throws ApiError
+   */
+  deleteEnv(requestBody) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/env",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Single Environment Variable
+   * Retrieve a specific environment variable
+   * @param key
+   * @param requestBody
+   * @returns EnvResponse Environment variable retrieved successfully
+   * @throws ApiError
+   */
+  getEnv(key, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/{key}",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Environment Variable
+   * Update an existing environment variable
+   * @param key
+   * @param requestBody
+   * @returns EnvResponse Environment variable updated successfully
+   * @throws ApiError
+   */
+  updateEnv(key, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/env/{key}",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Environment Variable
+   * Create a new environment variable
+   * @param requestBody
+   * @returns EnvResponse Environment variable created successfully
+   * @throws ApiError
+   */
+  createEnv(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/env/single",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Batch Create Environment Variables
+   * Create multiple environment variables in a single request
+   * @param requestBody
+   * @returns EnvsResponse Environment variables created successfully
+   * @throws ApiError
+   */
+  batchCreateEnvs(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OnboardingService.ts
+var OnboardingService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Create Organization Invite
+   * Create an organization invite
+   * @param requestBody
+   * @returns CreateOrgInviteResponse Successful greeting response
+   * @throws ApiError
+   */
+  createOrgInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/onboarding/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Organization Invite by Code
+   * Get organization invite by code
+   * @param inviteCode
+   * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+   * @throws ApiError
+   */
+  getOrgInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/org/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept Organization Invite
+   * Accept organization invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+   * @throws ApiError
+   */
+  acceptOrgInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/onboarding/org/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get User Invite by Code
+   * Get user invite by code
+   * @param inviteCode
+   * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+   * @throws ApiError
+   */
+  getUserInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User Invite
+   * Update user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns UpdateUserInviteResponse User invite updated successfully
+   * @throws ApiError
+   */
+  updateUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept User Invite
+   * Accept user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptUserInviteResponse User invite accepted successfully
+   * @throws ApiError
+   */
+  acceptUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/onboarding/user/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create User Invite
+   * Create a user invite
+   * @param requestBody
+   * @returns CreateUserInviteResponse User invite created successfully
+   * @throws ApiError
+   */
+  createUserInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/onboarding/user",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete User Invite
+   * Delete user invite
+   * @param inviteId
+   * @param requestBody
+   * @returns DeleteUserInviteResponse User invite deleted successfully
+   * @throws ApiError
+   */
+  deleteUserInvite(inviteId, requestBody) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/onboarding/user/{invite_id}",
+      path: {
+        "invite_id": inviteId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OrganizationsService.ts
+var OrganizationsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Organization
+   * Retrieve the current organization's details
+   * @returns OrgResponse Organization retrieved successfully
+   * @throws ApiError
+   */
+  getOrg() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/org",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Organization
+   * Update the current organization's details
+   * @param requestBody
+   * @returns OrgResponse Organization updated successfully
+   * @throws ApiError
+   */
+  updateOrg(requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Check Slug Availability
+   * Check if an organization slug is available
+   * @param slug
+   * @returns CheckSlugResponse Slug availability checked successfully
+   * @throws ApiError
+   */
+  checkIfSlugExists(slug) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/org/check-slug",
+      query: {
+        "slug": slug
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/UsersService.ts
+var UsersService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get All Users
+   * Retrieve all users in the organization
+   * @returns UsersResponse Users retrieved successfully
+   * @throws ApiError
+   */
+  getUsers() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/user",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get User by ID
+   * Retrieve a specific user by their ID
+   * @param id
+   * @returns UserResponse User retrieved successfully
+   * @throws ApiError
+   */
+  getUserById(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/user/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User
+   * Update a user's profile information
+   * @param id
+   * @param requestBody
+   * @returns UserResponse User updated successfully
+   * @throws ApiError
+   */
+  updateUser(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/user/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete User
+   * Delete a user from the organization (Admin only)
+   * @param id
+   * @returns UserResponse User deleted successfully
+   * @throws ApiError
+   */
+  deleteUser(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/user/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User Role
+   * Update a user's role (Admin only)
+   * @param id
+   * @param requestBody
+   * @returns UserResponse User role updated successfully
+   * @throws ApiError
+   */
+  updateRole(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/user/role/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User Password
+   * Update a user's password (Admin only)
+   * @param id
+   * @param requestBody
+   * @returns UserResponse Password update request sent successfully
+   * @throws ApiError
+   */
+  updatePassword(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/user/password/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/EnvSyncAPISDK.ts
+var EnvSyncAPISDK = class {
+  applications;
+  auditLogs;
+  authentication;
+  environmentTypes;
+  environmentVariables;
+  onboarding;
+  organizations;
+  users;
+  request;
+  constructor(config, HttpRequest = FetchHttpRequest) {
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? "http://localhost:8600",
+      VERSION: config?.VERSION ?? "0.0.0",
+      WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+      CREDENTIALS: config?.CREDENTIALS ?? "include",
+      TOKEN: config?.TOKEN,
+      USERNAME: config?.USERNAME,
+      PASSWORD: config?.PASSWORD,
+      HEADERS: config?.HEADERS,
+      ENCODE_PATH: config?.ENCODE_PATH
+    });
+    this.applications = new ApplicationsService(this.request);
+    this.auditLogs = new AuditLogsService(this.request);
+    this.authentication = new AuthenticationService(this.request);
+    this.environmentTypes = new EnvironmentTypesService(this.request);
+    this.environmentVariables = new EnvironmentVariablesService(this.request);
+    this.onboarding = new OnboardingService(this.request);
+    this.organizations = new OrganizationsService(this.request);
+    this.users = new UsersService(this.request);
+  }
+};
+
+// src/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "http://localhost:8600",
+  VERSION: "0.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+export {
+  ApiError,
+  ApplicationsService,
+  AuditLogsService,
+  AuthenticationService,
+  BaseHttpRequest,
+  CancelError,
+  CancelablePromise,
+  EnvSyncAPISDK,
+  EnvironmentTypesService,
+  EnvironmentVariablesService,
+  OnboardingService,
+  OpenAPI,
+  OrganizationsService,
+  UsersService
+};