@envsync-cloud/envsync-ts-sdk 0.1.0

package/dist/index.global.js

@@ -0,0 +1,1150 @@
+"use strict";
+(() => {
+  // 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
+  };
+})();