@envsync-cloud/envsync-management-ts-sdk 0.8.5

package/dist/index.js

@@ -0,0 +1,1210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiError: () => ApiError,
+  BaseHttpRequest: () => BaseHttpRequest,
+  CancelError: () => CancelError,
+  CancelablePromise: () => CancelablePromise,
+  CreateIntegrationBindingRequest: () => CreateIntegrationBindingRequest,
+  CreateManualSyncRunRequest: () => CreateManualSyncRunRequest,
+  CreateProviderConnectionRequest: () => CreateProviderConnectionRequest,
+  EnterpriseProviderProfile: () => EnterpriseProviderProfile,
+  EnterpriseService: () => EnterpriseService,
+  EnvSyncManagementAPISDK: () => EnvSyncManagementAPISDK,
+  IntegrationBinding: () => IntegrationBinding,
+  LicenseService: () => LicenseService,
+  LicenseState: () => LicenseState,
+  OnboardingService: () => OnboardingService,
+  OpenAPI: () => OpenAPI,
+  ProviderConnection: () => ProviderConnection,
+  SyncAuditEvent: () => SyncAuditEvent,
+  SyncRun: () => SyncRun,
+  SystemService: () => SystemService,
+  SystemStatusState: () => SystemStatusState,
+  UpdateProviderConnectionRequest: () => UpdateProviderConnectionRequest
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/EnterpriseService.ts
+var EnterpriseService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * List Enterprise Providers
+   * @returns EnterpriseProvidersResponse Enterprise provider catalog
+   * @throws ApiError
+   */
+  listEnterpriseProviders() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/providers",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Enterprise Org Secret Model
+   * @returns OrgSecretModelResponse Org secret model
+   * @throws ApiError
+   */
+  getEnterpriseOrgSecretModel() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/org-secrets/model",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Provider Connections
+   * @returns ProviderConnectionsResponse Provider connections
+   * @throws ApiError
+   */
+  listEnterpriseProviderConnections() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/provider-connections",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Provider Connection
+   * @param requestBody
+   * @returns ProviderConnection Provider connection created
+   * @throws ApiError
+   */
+  createEnterpriseProviderConnection(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/enterprise/provider-connections",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Enterprise Provider Connection
+   * @param id
+   * @param requestBody
+   * @returns ProviderConnection Provider connection updated
+   * @throws ApiError
+   */
+  updateEnterpriseProviderConnection(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/enterprise/provider-connections/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Org Secrets
+   * @returns OrgSecretsResponse Org secrets
+   * @throws ApiError
+   */
+  listEnterpriseOrgSecrets() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/org-secrets",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Org Secret
+   * @param requestBody
+   * @returns OrgSecret Org secret created
+   * @throws ApiError
+   */
+  createEnterpriseOrgSecret(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/enterprise/org-secrets",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Enterprise Org Secret
+   * @param id
+   * @param requestBody
+   * @returns OrgSecret Org secret updated
+   * @throws ApiError
+   */
+  updateEnterpriseOrgSecret(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/enterprise/org-secrets/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Integration Bindings
+   * @param appId
+   * @returns IntegrationBindingsResponse Integration bindings
+   * @throws ApiError
+   */
+  listEnterpriseIntegrationBindings(appId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/apps/{app_id}/bindings",
+      path: {
+        "app_id": appId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Integration Binding
+   * @param appId
+   * @param requestBody
+   * @returns IntegrationBinding Integration binding created
+   * @throws ApiError
+   */
+  createEnterpriseIntegrationBinding(appId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/enterprise/apps/{app_id}/bindings",
+      path: {
+        "app_id": appId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Enterprise Integration Binding
+   * @param appId
+   * @param id
+   * @param requestBody
+   * @returns IntegrationBinding Integration binding updated
+   * @throws ApiError
+   */
+  updateEnterpriseIntegrationBinding(appId, id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/enterprise/apps/{app_id}/bindings/{id}",
+      path: {
+        "app_id": appId,
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Env-Type Mappings
+   * @param appId
+   * @returns EnvTypeMappingsResponse Env-type mappings
+   * @throws ApiError
+   */
+  listEnterpriseEnvTypeMappings(appId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/apps/{app_id}/env-type-mappings",
+      path: {
+        "app_id": appId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Env-Type Mapping
+   * @param appId
+   * @param requestBody
+   * @returns EnvTypeMapping Env-type mapping created
+   * @throws ApiError
+   */
+  createEnterpriseEnvTypeMapping(appId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/enterprise/apps/{app_id}/env-type-mappings",
+      path: {
+        "app_id": appId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Enterprise Env-Type Mapping
+   * @param appId
+   * @param id
+   * @param requestBody
+   * @returns EnvTypeMapping Env-type mapping updated
+   * @throws ApiError
+   */
+  updateEnterpriseEnvTypeMapping(appId, id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/enterprise/apps/{app_id}/env-type-mappings/{id}",
+      path: {
+        "app_id": appId,
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Sync Runs
+   * @returns SyncRunsResponse Sync runs
+   * @throws ApiError
+   */
+  listEnterpriseSyncRuns() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/sync-runs",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Manual Sync Run
+   * @param requestBody
+   * @returns SyncRun Sync run created
+   * @throws ApiError
+   */
+  createEnterpriseManualSyncRun(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/enterprise/sync-runs/manual",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Sync Audit Events
+   * @param syncRunId
+   * @returns SyncAuditEventsResponse Sync audit events
+   * @throws ApiError
+   */
+  listEnterpriseSyncAuditEvents(syncRunId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/enterprise/sync-runs/{sync_run_id}/events",
+      path: {
+        "sync_run_id": syncRunId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/LicenseService.ts
+var LicenseService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Management License Status
+   * @returns LicenseStatusResponse Current license status
+   * @throws ApiError
+   */
+  getManagementLicenseStatus() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/license/status",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Activate Management License
+   * @returns LicenseActionResponse License activated
+   * @throws ApiError
+   */
+  activateManagementLicense() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/license/activate",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Verify Management License
+   * @returns LicenseActionResponse License verified
+   * @throws ApiError
+   */
+  verifyManagementLicense() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/license/verify",
+      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`
+      }
+    });
+  }
+  /**
+   * Get All User Invites
+   * Get all user invites
+   * @returns GetUserInviteByTokenResponse User invites retrieved successfully
+   * @throws ApiError
+   */
+  getAllUserInvites() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/user",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete User Invite
+   * Delete user invite
+   * @param inviteId
+   * @returns DeleteUserInviteResponse User invite deleted successfully
+   * @throws ApiError
+   */
+  deleteUserInvite(inviteId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/onboarding/user/{invite_id}",
+      path: {
+        "invite_id": inviteId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/SystemService.ts
+var SystemService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Management System Status
+   * @returns SystemStatusResponse Management system status
+   * @throws ApiError
+   */
+  getManagementSystemStatus() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/system/status",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/EnvSyncManagementAPISDK.ts
+var EnvSyncManagementAPISDK = class {
+  enterprise;
+  license;
+  onboarding;
+  system;
+  request;
+  constructor(config, HttpRequest = FetchHttpRequest) {
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? "http://localhost:4001",
+      VERSION: config?.VERSION ?? "0.8.5",
+      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.enterprise = new EnterpriseService(this.request);
+    this.license = new LicenseService(this.request);
+    this.onboarding = new OnboardingService(this.request);
+    this.system = new SystemService(this.request);
+  }
+};
+
+// src/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "http://localhost:4001",
+  VERSION: "0.8.5",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// src/models/CreateIntegrationBindingRequest.ts
+var CreateIntegrationBindingRequest;
+((CreateIntegrationBindingRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateIntegrationBindingRequest2.provider_type || (CreateIntegrationBindingRequest2.provider_type = {}));
+})(CreateIntegrationBindingRequest || (CreateIntegrationBindingRequest = {}));
+
+// src/models/CreateManualSyncRunRequest.ts
+var CreateManualSyncRunRequest;
+((CreateManualSyncRunRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateManualSyncRunRequest2.provider_type || (CreateManualSyncRunRequest2.provider_type = {}));
+})(CreateManualSyncRunRequest || (CreateManualSyncRunRequest = {}));
+
+// src/models/CreateProviderConnectionRequest.ts
+var CreateProviderConnectionRequest;
+((CreateProviderConnectionRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateProviderConnectionRequest2.provider_type || (CreateProviderConnectionRequest2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = CreateProviderConnectionRequest2.status || (CreateProviderConnectionRequest2.status = {}));
+})(CreateProviderConnectionRequest || (CreateProviderConnectionRequest = {}));
+
+// src/models/EnterpriseProviderProfile.ts
+var EnterpriseProviderProfile;
+((EnterpriseProviderProfile2) => {
+  let id;
+  ((id2) => {
+    id2["GITHUB"] = "github";
+    id2["GITLAB"] = "gitlab";
+    id2["AWS_SSM"] = "aws-ssm";
+    id2["VERCEL"] = "vercel";
+    id2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(id = EnterpriseProviderProfile2.id || (EnterpriseProviderProfile2.id = {}));
+})(EnterpriseProviderProfile || (EnterpriseProviderProfile = {}));
+
+// src/models/IntegrationBinding.ts
+var IntegrationBinding;
+((IntegrationBinding2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = IntegrationBinding2.provider_type || (IntegrationBinding2.provider_type = {}));
+})(IntegrationBinding || (IntegrationBinding = {}));
+
+// src/models/LicenseState.ts
+var LicenseState;
+((LicenseState2) => {
+  let status;
+  ((status2) => {
+    status2["UNKNOWN"] = "unknown";
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["EXPIRED"] = "expired";
+    status2["ERROR"] = "error";
+    status2["LOCKED"] = "locked";
+  })(status = LicenseState2.status || (LicenseState2.status = {}));
+})(LicenseState || (LicenseState = {}));
+
+// src/models/ProviderConnection.ts
+var ProviderConnection;
+((ProviderConnection2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = ProviderConnection2.provider_type || (ProviderConnection2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = ProviderConnection2.status || (ProviderConnection2.status = {}));
+})(ProviderConnection || (ProviderConnection = {}));
+
+// src/models/SyncAuditEvent.ts
+var SyncAuditEvent;
+((SyncAuditEvent2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = SyncAuditEvent2.provider_type || (SyncAuditEvent2.provider_type = {}));
+  let result;
+  ((result2) => {
+    result2["INFO"] = "info";
+    result2["SUCCESS"] = "success";
+    result2["ERROR"] = "error";
+  })(result = SyncAuditEvent2.result || (SyncAuditEvent2.result = {}));
+})(SyncAuditEvent || (SyncAuditEvent = {}));
+
+// src/models/SyncRun.ts
+var SyncRun;
+((SyncRun2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = SyncRun2.provider_type || (SyncRun2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["RUNNING"] = "running";
+    status2["SUCCEEDED"] = "succeeded";
+    status2["FAILED"] = "failed";
+  })(status = SyncRun2.status || (SyncRun2.status = {}));
+})(SyncRun || (SyncRun = {}));
+
+// src/models/SystemStatusState.ts
+var SystemStatusState;
+((SystemStatusState2) => {
+  let edition;
+  ((edition2) => {
+    edition2["OSS"] = "oss";
+    edition2["ENTERPRISE"] = "enterprise";
+  })(edition = SystemStatusState2.edition || (SystemStatusState2.edition = {}));
+})(SystemStatusState || (SystemStatusState = {}));
+
+// src/models/UpdateProviderConnectionRequest.ts
+var UpdateProviderConnectionRequest;
+((UpdateProviderConnectionRequest2) => {
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = UpdateProviderConnectionRequest2.status || (UpdateProviderConnectionRequest2.status = {}));
+})(UpdateProviderConnectionRequest || (UpdateProviderConnectionRequest = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  BaseHttpRequest,
+  CancelError,
+  CancelablePromise,
+  CreateIntegrationBindingRequest,
+  CreateManualSyncRunRequest,
+  CreateProviderConnectionRequest,
+  EnterpriseProviderProfile,
+  EnterpriseService,
+  EnvSyncManagementAPISDK,
+  IntegrationBinding,
+  LicenseService,
+  LicenseState,
+  OnboardingService,
+  OpenAPI,
+  ProviderConnection,
+  SyncAuditEvent,
+  SyncRun,
+  SystemService,
+  SystemStatusState,
+  UpdateProviderConnectionRequest
+});
+//# sourceMappingURL=index.js.map