@camunda/ccma-api 0.0.2 → 0.0.3

package/dist/services/accounts/orgs.service.js

@@ -0,0 +1,978 @@
+import {
+  MINUTE
+} from "@camunda/ccma-shared-types";
+import { request } from "../../utils/api.js";
+import { Cache } from "../../utils/cache.js";
+import { HttpError } from "../../utils/errors.js";
+const orgCache = new Cache(5 * MINUTE);
+const ownerCache = new Cache(60 * MINUTE);
+const memberCache = new Cache(60 * MINUTE);
+const rolesCache = new Cache(60 * MINUTE);
+class OrgsService {
+  static async renameOrganization(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.renameOrganization`,
+        url: `api/organizations/${encodeURIComponent(params.params.orgId)}/`,
+        normalizedUrl: `api/organizations/:orgId/`,
+        type: "patch"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        newOrgName: params.params.newOrgName
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async getDetailsForOrgs(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getDetailsForOrgs`,
+        url: `api/organizations/orgInfos`,
+        normalizedUrl: `api/organizations/orgInfos`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        orgIds: params.orgIds
+      }
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getAllOrgs(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getAllOrgs`,
+        url: `api/organizations`,
+        normalizedUrl: `api/organizations`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getMyOrgs(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getMyOrgs`,
+        url: `api/organizations/my`,
+        normalizedUrl: `api/organizations/my`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getOrgInfo(params) {
+    if (!params.cacheControl?.ignoreCache) {
+      const inCache = orgCache.get(params.orgUuid);
+      if (inCache) {
+        return inCache;
+      }
+    }
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getOrgInfo`,
+        url: `api/organizations/${params.orgUuid}`,
+        normalizedUrl: `api/organizations/:orgUuid`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      headers: params.headers
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    orgCache.set(params.orgUuid, response.body);
+    return response.body;
+  }
+  static async getOwner(params) {
+    if (!params.cacheControl?.ignoreCache) {
+      const inCache = ownerCache.get(params.orgUuid);
+      if (inCache) {
+        return inCache;
+      }
+    }
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getOwner`,
+        url: `api/organizations/${params.orgUuid}/owner`,
+        normalizedUrl: `api/organizations/:orgUuid/owner`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      headers: params.headers
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    ownerCache.set(params.orgUuid, response.body);
+    return response.body;
+  }
+  static async createAndReturnSocialLoginUser(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.createAndReturnSocialLoginUser`,
+        url: `api/onboarding/social`,
+        normalizedUrl: `api/onboarding/social`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: params.body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return {
+      orgId: response.body?.orgId ?? "",
+      invitation: response.body?.invitation
+    };
+  }
+  static async getUsersOfOrg(params) {
+    if (!params.cacheControl?.ignoreCache) {
+      const inCache = memberCache.get(params.orgUuid);
+      if (inCache) {
+        return inCache;
+      }
+    }
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getUsersOfOrg`,
+        url: `api/organizations/${params.orgUuid}/users`,
+        normalizedUrl: `api/organizations/:orgUuid/users`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    memberCache.set(params.orgUuid, response.body);
+    return response.body;
+  }
+  static async getAllRoles(params) {
+    if (!params.cacheControl?.ignoreCache) {
+      const inCache = rolesCache.get("roles");
+      if (inCache) {
+        return inCache;
+      }
+    }
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getAllRoles`,
+        url: `api/roles`,
+        normalizedUrl: `api/roles`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    rolesCache.set("roles", response.body);
+    return response.body;
+  }
+  static async getNamesAndSalesplansForOrgs(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.getAllOrgs`,
+        url: `api/organizations/snowflake/getNamesAndSalesplansForOrgs`,
+        normalizedUrl: `api/organizations/snowflake/getNamesAndSalesplansForOrgs`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        orgIds: params.orgIds
+      }
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async markOrgHasAlreadyCreatedTemporaryCluster(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.markOrgHasAlreadyCreatedTemporaryCluster`,
+        url: `api/organizations/snowflake/${params.orgUuid}/markOrgHasAlreadyCreatedTemporaryCluster`,
+        normalizedUrl: `api/organizations/snowflake/:orgUuid/markOrgHasAlreadyCreatedTemporaryCluster`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async setSalesForceId(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.setSalesForceId`,
+        url: `api/organizations/${params.orgUuid}/salesForceId`,
+        normalizedUrl: `api/organizations/:orgUuid/salesForceId`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        salesForceId: params.salesForceId
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async setLimit(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.setLimit`,
+        url: `api/organizations/${params.params.orgId}/limits/${params.params.limitKey}`,
+        normalizedUrl: `api/organizations/:orgId/limits/:limitKey`,
+        type: "patch"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        value: params.params.limitValue,
+        onBehalfOf: params.params.onBehalfOf
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async updateSuppressDropDisks(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.updateSuppressDropDisks`,
+        url: `api/organizations/${params.params.orgId}/billing/limits/suppressDropDisks`,
+        normalizedUrl: `api/organizations/:orgId/billing/limits/suppressDropDisks`,
+        type: "patch"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        value: params.params.value
+      }
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async extendTrial(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.extendTrial`,
+        url: `api/organizations/${params.params.orgId}/extendtrial`,
+        normalizedUrl: `api/organizations/:orgId/extendtrial`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        newExpireDate: params.params.newExpireDate,
+        onBehalfOf: params.params.onBehalfOf
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async setAwsOnly(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.setAwsOnly`,
+        url: `api/organizations/${params.params.orgId}/awsOnly`,
+        normalizedUrl: `api/organizations/:orgId/awsOnly`,
+        type: "patch"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        awsOnly: params.params.awsOnly
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async setEnterpriseDevOnly(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.setEnterpriseDevOnly`,
+        url: `api/organizations/${params.params.orgId}/enterprise-dev`,
+        normalizedUrl: `api/organizations/:orgId/enterprise-dev`,
+        type: "patch"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        enterpriseDevOnly: params.params.enterpriseDevOnly
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async changeSalesPlan(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.changeSalesPlan`,
+        url: `api/organizations/${params.params.orgId}/salesplan/${params.params.salesPlanId}`,
+        normalizedUrl: `api/organizations/:orgId/salesplan/:salesPlanId`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: params.params.options ?? {}
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async convertTrialToInNegotiation(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.convertTrialToInNegotiation`,
+        url: `api/organizations/${params.params.orgId}/trial-to-in-negotiation/${params.params.salesPlanId}`,
+        normalizedUrl: `api/organizations/:orgId/trial-to-in-negotiation/:salesPlanId`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async sendInvite(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.sendInvite`,
+        url: `api/organizations/${params.params.orgId}/invites`,
+        normalizedUrl: `api/organizations/:orgId/invites`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        email: params.params.email,
+        orgRoles: params.params.orgRoles
+      }
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async checkUserExistsForInvite(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.checkUserExistsForInvite`,
+        url: `verification/invitation/${params.params.inviteToken}/check-user-exists`,
+        normalizedUrl: `verification/invitation/:inviteToken/check-user-exists`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async automatedEnterpriseOnboarding(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.automatedEnterpriseOnboarding`,
+        url: `external/onboarding`,
+        normalizedUrl: `external/onboarding`,
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        orgName: params.orgName,
+        awsOnly: params.awsOnly,
+        renewalTermInMonths: params.renewalTermInMonths,
+        valueMetrics: params.valueMetrics,
+        startDate: params.startDate,
+        sfdcId: params.sfdcId,
+        reservations: params.reservations,
+        ownerEmail: params.ownerEmail
+      },
+      responseType: "json"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async setBetaTermsAccepted(params) {
+    const serviceContext = {
+      method: {
+        name: "OrgsService.setBetaTermsAccepted",
+        url: `api/organizations/${encodeURIComponent(params.params.orgId)}/betaTerms`,
+        normalizedUrl: "api/organizations/:orgId/betaTerms",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        accepted: params.params.accepted
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  /**
+   * Delete an organization.
+   * This uses email-based authentication via x-camunda-email header.
+   * Only the owner of the org can delete it.
+   */
+  static async deleteOrganization(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.deleteOrganization`,
+        url: `api/organizations/${params.params.orgId}`,
+        normalizedUrl: `api/organizations/:orgId`,
+        type: "delete"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      headers: params.headers,
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async setAutoJoin(params) {
+    const serviceContext = {
+      method: {
+        name: `OrgsService.setAutoJoin`,
+        url: `api/organizations/${params.orgId}/auto-join`,
+        normalizedUrl: `api/organizations/:orgId/auto-join`,
+        type: "put"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      body: {
+        autoJoin: params.autoJoin
+      },
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getLLMUsageInfo(params) {
+    const serviceContext = {
+      method: {
+        name: "OrgsService.getLLMUsageInfo",
+        url: `api/organizations/${params.params.orgId}/llm/info`,
+        normalizedUrl: "api/organizations/:orgId/llm/info",
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async increaseLLMBudget(params) {
+    const serviceContext = {
+      method: {
+        name: "OrgsService.increaseLLMBudget",
+        url: `api/organizations/${params.params.orgId}/litellm/increase-budget`,
+        normalizedUrl: "api/organizations/:orgId/litellm/increase-budget",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async blockLiteLLM(params) {
+    const serviceContext = {
+      method: {
+        name: "OrgsService.blockLiteLLM",
+        url: `api/organizations/${params.params.orgId}/litellm/block`,
+        normalizedUrl: "api/organizations/:orgId/litellm/block",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+  static async unblockLiteLLM(params) {
+    const serviceContext = {
+      method: {
+        name: "OrgsService.unblockLiteLLM",
+        url: `api/organizations/${params.params.orgId}/litellm/unblock`,
+        normalizedUrl: "api/organizations/:orgId/litellm/unblock",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "accounts",
+        type: "internal"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: { id: "accounts" },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      responseType: "none"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+  }
+}
+export {
+  OrgsService
+};
+//# sourceMappingURL=orgs.service.js.map