@polar-sh/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3712 @@
+"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, {
+  AccountType: () => AccountType,
+  AccountsApi: () => AccountsApi,
+  BASE_PATH: () => BASE_PATH,
+  BackofficeApi: () => BackofficeApi,
+  BackofficeBadgeActionEnum: () => BackofficeBadgeActionEnum,
+  BackofficeBadgeResponseActionEnum: () => BackofficeBadgeResponseActionEnum,
+  BaseAPI: () => BaseAPI,
+  BlobApiResponse: () => BlobApiResponse,
+  COLLECTION_FORMATS: () => COLLECTION_FORMATS,
+  Configuration: () => Configuration2,
+  DashboardApi: () => DashboardApi,
+  DefaultConfig: () => DefaultConfig,
+  ExtensionApi: () => ExtensionApi,
+  FetchError: () => FetchError,
+  FundingApi: () => FundingApi,
+  GetBadgeSettingsBadgeTypeEnum: () => GetBadgeSettingsBadgeTypeEnum,
+  GithubBadgeReadBadgeTypeEnum: () => GithubBadgeReadBadgeTypeEnum,
+  HealthApi: () => HealthApi,
+  InstallationCreatePlatformEnum: () => InstallationCreatePlatformEnum,
+  IntegrationsApi: () => IntegrationsApi,
+  IssueListType: () => IssueListType,
+  IssueReferenceType: () => IssueReferenceType,
+  IssueSortBy: () => IssueSortBy,
+  IssueStateEnum: () => IssueStateEnum,
+  IssueStatus: () => IssueStatus,
+  IssuesApi: () => IssuesApi,
+  JSONApiResponse: () => JSONApiResponse,
+  ListFundingSortBy: () => ListFundingSortBy,
+  MagicLinkApi: () => MagicLinkApi,
+  NotificationType: () => NotificationType,
+  NotificationsApi: () => NotificationsApi,
+  OrganizationsApi: () => OrganizationsApi,
+  PaymentMethodTypeEnum: () => PaymentMethodTypeEnum,
+  PaymentMethodsApi: () => PaymentMethodsApi,
+  PersonalAccessTokenApi: () => PersonalAccessTokenApi,
+  Platforms: () => Platforms,
+  PledgeState: () => PledgeState,
+  PledgeStripePaymentIntentCreateSetupFutureUsageEnum: () => PledgeStripePaymentIntentCreateSetupFutureUsageEnum,
+  PledgeStripePaymentIntentUpdateSetupFutureUsageEnum: () => PledgeStripePaymentIntentUpdateSetupFutureUsageEnum,
+  PledgeType: () => PledgeType,
+  PledgesApi: () => PledgesApi,
+  PolarAPI: () => PolarAPI,
+  PullRequestsApi: () => PullRequestsApi,
+  RepositoriesApi: () => RepositoriesApi,
+  RequiredError: () => RequiredError,
+  ResponseError: () => ResponseError,
+  RewardState: () => RewardState,
+  RewardsApi: () => RewardsApi,
+  StreamApi: () => StreamApi,
+  SubscriptionsApi: () => SubscriptionsApi,
+  TextApiResponse: () => TextApiResponse,
+  UserSignupType: () => UserSignupType,
+  UsersApi: () => UsersApi,
+  Visibility: () => Visibility,
+  VoidApiResponse: () => VoidApiResponse,
+  canConsumeForm: () => canConsumeForm,
+  querystring: () => querystring
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client/PolarAPI.ts
+var PolarAPI = class {
+  accounts;
+  backoffice;
+  dashboard;
+  extension;
+  funding;
+  health;
+  integrations;
+  issues;
+  magicLink;
+  notifications;
+  organizations;
+  paymentMethods;
+  personalAccessToken;
+  pledges;
+  pullRequests;
+  repositories;
+  rewards;
+  stream;
+  users;
+  constructor(config) {
+    this.accounts = new AccountsApi(config);
+    this.backoffice = new BackofficeApi(config);
+    this.dashboard = new DashboardApi(config);
+    this.extension = new ExtensionApi(config);
+    this.funding = new FundingApi(config);
+    this.health = new HealthApi(config);
+    this.integrations = new IntegrationsApi(config);
+    this.issues = new IssuesApi(config);
+    this.magicLink = new MagicLinkApi(config);
+    this.notifications = new NotificationsApi(config);
+    this.organizations = new OrganizationsApi(config);
+    this.paymentMethods = new PaymentMethodsApi(config);
+    this.personalAccessToken = new PersonalAccessTokenApi(config);
+    this.pledges = new PledgesApi(config);
+    this.pullRequests = new PullRequestsApi(config);
+    this.repositories = new RepositoriesApi(config);
+    this.rewards = new RewardsApi(config);
+    this.stream = new StreamApi(config);
+    this.users = new UsersApi(config);
+  }
+};
+
+// src/client/runtime.ts
+var BASE_PATH = "https://api.polar.sh".replace(/\/+$/, "");
+var Configuration2 = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration2();
+var BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$", "i");
+  middleware;
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = void 0;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : void 0
+          }) || response;
+        }
+      }
+      if (response === void 0) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  name = "ResponseError";
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+  name = "FetchError";
+};
+var RequiredError = class extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+  name = "RequiredError";
+};
+var COLLECTION_FORMATS = {
+  csv: ",",
+  ssv: " ",
+  tsv: "	",
+  pipes: "|"
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+function canConsumeForm(consumes) {
+  for (const consume of consumes) {
+    if ("multipart/form-data" === consume.contentType) {
+      return true;
+    }
+  }
+  return false;
+}
+var JSONApiResponse = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+};
+var VoidApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return void 0;
+  }
+};
+var BlobApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.blob();
+  }
+};
+var TextApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.text();
+  }
+};
+
+// src/client/apis/AccountsApi.ts
+var AccountsApi = class extends BaseAPI {
+  /**
+   * Create
+   */
+  async createRaw(requestParameters, initOverrides) {
+    if (requestParameters.accountCreate === null || requestParameters.accountCreate === void 0) {
+      throw new RequiredError("accountCreate", "Required parameter requestParameters.accountCreate was null or undefined when calling create.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/accounts`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.accountCreate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create
+   */
+  async create(requestParameters, initOverrides) {
+    const response = await this.createRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Dashboard Link
+   */
+  async dashboardLinkRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling dashboardLink.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/accounts/{id}/dashboard_link`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Dashboard Link
+   */
+  async dashboardLink(requestParameters, initOverrides) {
+    const response = await this.dashboardLinkRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get
+   */
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling get.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/accounts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get
+   */
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Onboarding Link
+   */
+  async onboardingLinkRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling onboardingLink.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/accounts/{id}/onboarding_link`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Onboarding Link
+   */
+  async onboardingLink(requestParameters, initOverrides) {
+    const response = await this.onboardingLinkRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.organizationId !== void 0) {
+      queryParameters["organization_id"] = requestParameters.organizationId;
+    }
+    if (requestParameters.userId !== void 0) {
+      queryParameters["user_id"] = requestParameters.userId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/accounts/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search
+   */
+  async search(requestParameters = {}, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/BackofficeApi.ts
+var BackofficeApi = class extends BaseAPI {
+  /**
+   * Issue
+   */
+  async issueRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling issue.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/issue/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Issue
+   */
+  async issue(requestParameters, initOverrides) {
+    const response = await this.issueRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Manage Badge
+   */
+  async manageBadgeRaw(requestParameters, initOverrides) {
+    if (requestParameters.backofficeBadge === null || requestParameters.backofficeBadge === void 0) {
+      throw new RequiredError("backofficeBadge", "Required parameter requestParameters.backofficeBadge was null or undefined when calling manageBadge.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/badge`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.backofficeBadge
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Manage Badge
+   */
+  async manageBadge(requestParameters, initOverrides) {
+    const response = await this.manageBadgeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Organization Sync
+   */
+  async organizationSyncRaw(requestParameters, initOverrides) {
+    if (requestParameters.name === null || requestParameters.name === void 0) {
+      throw new RequiredError("name", "Required parameter requestParameters.name was null or undefined when calling organizationSync.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/organization/sync/{name}`.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters.name))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Organization Sync
+   */
+  async organizationSync(requestParameters, initOverrides) {
+    const response = await this.organizationSyncRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Pledge Create Invoice
+   */
+  async pledgeCreateInvoiceRaw(requestParameters, initOverrides) {
+    if (requestParameters.pledgeId === null || requestParameters.pledgeId === void 0) {
+      throw new RequiredError("pledgeId", "Required parameter requestParameters.pledgeId was null or undefined when calling pledgeCreateInvoice.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/pledges/create_invoice/{pledge_id}`.replace(`{${"pledge_id"}}`, encodeURIComponent(String(requestParameters.pledgeId))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Pledge Create Invoice
+   */
+  async pledgeCreateInvoice(requestParameters, initOverrides) {
+    const response = await this.pledgeCreateInvoiceRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Pledge Mark Disputed
+   */
+  async pledgeMarkDisputedRaw(requestParameters, initOverrides) {
+    if (requestParameters.pledgeId === null || requestParameters.pledgeId === void 0) {
+      throw new RequiredError("pledgeId", "Required parameter requestParameters.pledgeId was null or undefined when calling pledgeMarkDisputed.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/pledges/mark_disputed/{pledge_id}`.replace(`{${"pledge_id"}}`, encodeURIComponent(String(requestParameters.pledgeId))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Pledge Mark Disputed
+   */
+  async pledgeMarkDisputed(requestParameters, initOverrides) {
+    const response = await this.pledgeMarkDisputedRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Pledge Reward Transfer
+   */
+  async pledgeRewardTransferRaw(requestParameters, initOverrides) {
+    if (requestParameters.pledgeRewardTransfer === null || requestParameters.pledgeRewardTransfer === void 0) {
+      throw new RequiredError("pledgeRewardTransfer", "Required parameter requestParameters.pledgeRewardTransfer was null or undefined when calling pledgeRewardTransfer.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/pledges/approve`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.pledgeRewardTransfer
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Pledge Reward Transfer
+   */
+  async pledgeRewardTransfer(requestParameters, initOverrides) {
+    const response = await this.pledgeRewardTransferRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Pledges
+   */
+  async pledgesRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/pledges`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Pledges
+   */
+  async pledges(initOverrides) {
+    const response = await this.pledgesRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Rewards
+   */
+  async rewardsRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.issueId !== void 0) {
+      queryParameters["issue_id"] = requestParameters.issueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/rewards/by_issue`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Rewards
+   */
+  async rewards(requestParameters = {}, initOverrides) {
+    const response = await this.rewardsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Rewards Pending
+   */
+  async rewardsPendingRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/backoffice/rewards/pending`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Rewards Pending
+   */
+  async rewardsPending(initOverrides) {
+    const response = await this.rewardsPendingRaw(initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/DashboardApi.ts
+var DashboardApi = class extends BaseAPI {
+  /**
+   * Dummy Do Not Use
+   */
+  async dummyDoNotUseRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/dashboard/dummy_do_not_use`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Dummy Do Not Use
+   */
+  async dummyDoNotUse(initOverrides) {
+    const response = await this.dummyDoNotUseRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get Dashboard
+   */
+  async getDashboardRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling getDashboard.");
+    }
+    if (requestParameters.orgName === null || requestParameters.orgName === void 0) {
+      throw new RequiredError("orgName", "Required parameter requestParameters.orgName was null or undefined when calling getDashboard.");
+    }
+    const queryParameters = {};
+    if (requestParameters.repoName !== void 0) {
+      queryParameters["repo_name"] = requestParameters.repoName;
+    }
+    if (requestParameters.issueListType !== void 0) {
+      queryParameters["issue_list_type"] = requestParameters.issueListType;
+    }
+    if (requestParameters.status) {
+      queryParameters["status"] = requestParameters.status;
+    }
+    if (requestParameters.q !== void 0) {
+      queryParameters["q"] = requestParameters.q;
+    }
+    if (requestParameters.sort !== void 0) {
+      queryParameters["sort"] = requestParameters.sort;
+    }
+    if (requestParameters.onlyPledged !== void 0) {
+      queryParameters["only_pledged"] = requestParameters.onlyPledged;
+    }
+    if (requestParameters.onlyBadged !== void 0) {
+      queryParameters["only_badged"] = requestParameters.onlyBadged;
+    }
+    if (requestParameters.page !== void 0) {
+      queryParameters["page"] = requestParameters.page;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/dashboard/{platform}/{org_name}`.replace(`{${"platform"}}`, encodeURIComponent(String(requestParameters.platform))).replace(`{${"org_name"}}`, encodeURIComponent(String(requestParameters.orgName))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get Dashboard
+   */
+  async getDashboard(requestParameters, initOverrides) {
+    const response = await this.getDashboardRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get Personal Dashboard
+   */
+  async getPersonalDashboardRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.issueListType !== void 0) {
+      queryParameters["issue_list_type"] = requestParameters.issueListType;
+    }
+    if (requestParameters.status) {
+      queryParameters["status"] = requestParameters.status;
+    }
+    if (requestParameters.q !== void 0) {
+      queryParameters["q"] = requestParameters.q;
+    }
+    if (requestParameters.sort !== void 0) {
+      queryParameters["sort"] = requestParameters.sort;
+    }
+    if (requestParameters.onlyPledged !== void 0) {
+      queryParameters["only_pledged"] = requestParameters.onlyPledged;
+    }
+    if (requestParameters.onlyBadged !== void 0) {
+      queryParameters["only_badged"] = requestParameters.onlyBadged;
+    }
+    if (requestParameters.page !== void 0) {
+      queryParameters["page"] = requestParameters.page;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/dashboard/personal`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get Personal Dashboard
+   */
+  async getPersonalDashboard(requestParameters = {}, initOverrides) {
+    const response = await this.getPersonalDashboardRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/ExtensionApi.ts
+var ExtensionApi = class extends BaseAPI {
+  /**
+   * List Issues For Extension
+   */
+  async listIssuesForExtensionRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling listIssuesForExtension.");
+    }
+    if (requestParameters.orgName === null || requestParameters.orgName === void 0) {
+      throw new RequiredError("orgName", "Required parameter requestParameters.orgName was null or undefined when calling listIssuesForExtension.");
+    }
+    if (requestParameters.repoName === null || requestParameters.repoName === void 0) {
+      throw new RequiredError("repoName", "Required parameter requestParameters.repoName was null or undefined when calling listIssuesForExtension.");
+    }
+    if (requestParameters.numbers === null || requestParameters.numbers === void 0) {
+      throw new RequiredError("numbers", "Required parameter requestParameters.numbers was null or undefined when calling listIssuesForExtension.");
+    }
+    const queryParameters = {};
+    if (requestParameters.numbers !== void 0) {
+      queryParameters["numbers"] = requestParameters.numbers;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/extension/{platform}/{org_name}/{repo_name}/issues`.replace(`{${"platform"}}`, encodeURIComponent(String(requestParameters.platform))).replace(`{${"org_name"}}`, encodeURIComponent(String(requestParameters.orgName))).replace(`{${"repo_name"}}`, encodeURIComponent(String(requestParameters.repoName))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * List Issues For Extension
+   */
+  async listIssuesForExtension(requestParameters, initOverrides) {
+    const response = await this.listIssuesForExtensionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/FundingApi.ts
+var FundingApi = class extends BaseAPI {
+  /**
+   * Lookup
+   */
+  async lookupRaw(requestParameters, initOverrides) {
+    if (requestParameters.issueId === null || requestParameters.issueId === void 0) {
+      throw new RequiredError("issueId", "Required parameter requestParameters.issueId was null or undefined when calling lookup.");
+    }
+    const queryParameters = {};
+    if (requestParameters.issueId !== void 0) {
+      queryParameters["issue_id"] = requestParameters.issueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/funding/lookup`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Lookup
+   */
+  async lookup(requestParameters, initOverrides) {
+    const response = await this.lookupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    if (requestParameters.organizationName === null || requestParameters.organizationName === void 0) {
+      throw new RequiredError("organizationName", "Required parameter requestParameters.organizationName was null or undefined when calling search.");
+    }
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling search.");
+    }
+    const queryParameters = {};
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    if (requestParameters.badged !== void 0) {
+      queryParameters["badged"] = requestParameters.badged;
+    }
+    if (requestParameters.closed !== void 0) {
+      queryParameters["closed"] = requestParameters.closed;
+    }
+    if (requestParameters.sorting) {
+      queryParameters["sorting"] = requestParameters.sorting;
+    }
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.page !== void 0) {
+      queryParameters["page"] = requestParameters.page;
+    }
+    if (requestParameters.limit !== void 0) {
+      queryParameters["limit"] = requestParameters.limit;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/funding/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search
+   */
+  async search(requestParameters, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/HealthApi.ts
+var HealthApi = class extends BaseAPI {
+  /**
+   * Healthz
+   */
+  async healthzRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/healthz`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Healthz
+   */
+  async healthz(initOverrides) {
+    const response = await this.healthzRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Readyz
+   */
+  async readyzRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/readyz`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Readyz
+   */
+  async readyz(initOverrides) {
+    const response = await this.readyzRaw(initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/IntegrationsApi.ts
+var IntegrationsApi = class extends BaseAPI {
+  /**
+   * Get Badge Settings
+   */
+  async getBadgeSettingsRaw(requestParameters, initOverrides) {
+    if (requestParameters.org === null || requestParameters.org === void 0) {
+      throw new RequiredError("org", "Required parameter requestParameters.org was null or undefined when calling getBadgeSettings.");
+    }
+    if (requestParameters.repo === null || requestParameters.repo === void 0) {
+      throw new RequiredError("repo", "Required parameter requestParameters.repo was null or undefined when calling getBadgeSettings.");
+    }
+    if (requestParameters.number === null || requestParameters.number === void 0) {
+      throw new RequiredError("number", "Required parameter requestParameters.number was null or undefined when calling getBadgeSettings.");
+    }
+    if (requestParameters.badgeType === null || requestParameters.badgeType === void 0) {
+      throw new RequiredError("badgeType", "Required parameter requestParameters.badgeType was null or undefined when calling getBadgeSettings.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/{org}/{repo}/issues/{number}/badges/{badge_type}`.replace(`{${"org"}}`, encodeURIComponent(String(requestParameters.org))).replace(`{${"repo"}}`, encodeURIComponent(String(requestParameters.repo))).replace(`{${"number"}}`, encodeURIComponent(String(requestParameters.number))).replace(`{${"badge_type"}}`, encodeURIComponent(String(requestParameters.badgeType))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get Badge Settings
+   */
+  async getBadgeSettings(requestParameters, initOverrides) {
+    const response = await this.getBadgeSettingsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Github Authorize
+   */
+  async githubAuthorizeRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.paymentIntentId !== void 0) {
+      queryParameters["payment_intent_id"] = requestParameters.paymentIntentId;
+    }
+    if (requestParameters.gotoUrl !== void 0) {
+      queryParameters["goto_url"] = requestParameters.gotoUrl;
+    }
+    if (requestParameters.userSignupType !== void 0) {
+      queryParameters["user_signup_type"] = requestParameters.userSignupType;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/authorize`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Github Authorize
+   */
+  async githubAuthorize(requestParameters = {}, initOverrides) {
+    const response = await this.githubAuthorizeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Github Callback
+   */
+  async githubCallbackRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.code !== void 0) {
+      queryParameters["code"] = requestParameters.code;
+    }
+    if (requestParameters.codeVerifier !== void 0) {
+      queryParameters["code_verifier"] = requestParameters.codeVerifier;
+    }
+    if (requestParameters.state !== void 0) {
+      queryParameters["state"] = requestParameters.state;
+    }
+    if (requestParameters.error !== void 0) {
+      queryParameters["error"] = requestParameters.error;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/callback`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Github Callback
+   */
+  async githubCallback(requestParameters = {}, initOverrides) {
+    const response = await this.githubCallbackRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Install
+   */
+  async installRaw(requestParameters, initOverrides) {
+    if (requestParameters.installationCreate === null || requestParameters.installationCreate === void 0) {
+      throw new RequiredError("installationCreate", "Required parameter requestParameters.installationCreate was null or undefined when calling install.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/installations`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.installationCreate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Install
+   */
+  async install(requestParameters, initOverrides) {
+    const response = await this.installRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Lookup User
+   */
+  async lookupUserRaw(requestParameters, initOverrides) {
+    if (requestParameters.lookupUserRequest === null || requestParameters.lookupUserRequest === void 0) {
+      throw new RequiredError("lookupUserRequest", "Required parameter requestParameters.lookupUserRequest was null or undefined when calling lookupUser.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/lookup_user`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.lookupUserRequest
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Lookup User
+   */
+  async lookupUser(requestParameters, initOverrides) {
+    const response = await this.lookupUserRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Stripe Connect Refresh
+   */
+  async stripeConnectRefreshRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/stripe/refresh`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Stripe Connect Refresh
+   */
+  async stripeConnectRefresh(initOverrides) {
+    const response = await this.stripeConnectRefreshRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Stripe Connect Return
+   */
+  async stripeConnectReturnRaw(requestParameters, initOverrides) {
+    if (requestParameters.stripeId === null || requestParameters.stripeId === void 0) {
+      throw new RequiredError("stripeId", "Required parameter requestParameters.stripeId was null or undefined when calling stripeConnectReturn.");
+    }
+    const queryParameters = {};
+    if (requestParameters.stripeId !== void 0) {
+      queryParameters["stripe_id"] = requestParameters.stripeId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/stripe/return`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Stripe Connect Return
+   */
+  async stripeConnectReturn(requestParameters, initOverrides) {
+    const response = await this.stripeConnectReturnRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Webhook
+   */
+  async webhookRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/github/webhook`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Webhook
+   */
+  async webhook(initOverrides) {
+    const response = await this.webhookRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Webhook
+   */
+  async webhook_1Raw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/integrations/stripe/webhook`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Webhook
+   */
+  async webhook_1(initOverrides) {
+    const response = await this.webhook_1Raw(initOverrides);
+    return await response.value();
+  }
+};
+var GetBadgeSettingsBadgeTypeEnum = {
+  PLEDGE: "pledge"
+};
+
+// src/client/apis/IssuesApi.ts
+var IssuesApi = class extends BaseAPI {
+  /**
+   * Add Issue Comment
+   */
+  async addIssueCommentRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling addIssueComment.");
+    }
+    if (requestParameters.postIssueComment === null || requestParameters.postIssueComment === void 0) {
+      throw new RequiredError("postIssueComment", "Required parameter requestParameters.postIssueComment was null or undefined when calling addIssueComment.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/comment`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.postIssueComment
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Add Issue Comment
+   */
+  async addIssueComment(requestParameters, initOverrides) {
+    const response = await this.addIssueCommentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Add Polar Badge
+   */
+  async addPolarBadgeRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling addPolarBadge.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/add_badge`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Add Polar Badge
+   */
+  async addPolarBadge(requestParameters, initOverrides) {
+    const response = await this.addPolarBadgeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Badge With Message
+   */
+  async badgeWithMessageRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling badgeWithMessage.");
+    }
+    if (requestParameters.issueUpdateBadgeMessage === null || requestParameters.issueUpdateBadgeMessage === void 0) {
+      throw new RequiredError("issueUpdateBadgeMessage", "Required parameter requestParameters.issueUpdateBadgeMessage was null or undefined when calling badgeWithMessage.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/badge_with_message`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.issueUpdateBadgeMessage
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Badge With Message
+   */
+  async badgeWithMessage(requestParameters, initOverrides) {
+    const response = await this.badgeWithMessageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Mark an issue as confirmed solved, and configure issue reward splits. Enables payouts of pledges. Can only be done once per issue. Requires authentication.
+   * Mark an issue as confirmed solved. (Public API)
+   */
+  async confirmRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling confirm.");
+    }
+    if (requestParameters.confirmIssue === null || requestParameters.confirmIssue === void 0) {
+      throw new RequiredError("confirmIssue", "Required parameter requestParameters.confirmIssue was null or undefined when calling confirm.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/confirm_solved`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.confirmIssue
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Mark an issue as confirmed solved, and configure issue reward splits. Enables payouts of pledges. Can only be done once per issue. Requires authentication.
+   * Mark an issue as confirmed solved. (Public API)
+   */
+  async confirm(requestParameters, initOverrides) {
+    const response = await this.confirmRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * For You
+   */
+  async forYouRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/for_you`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * For You
+   */
+  async forYou(initOverrides) {
+    const response = await this.forYouRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get issue
+   * Get issue (Public API)
+   */
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling get.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get issue
+   * Get issue (Public API)
+   */
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get Body
+   */
+  async getBodyRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling getBody.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/body`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Get Body
+   */
+  async getBody(requestParameters, initOverrides) {
+    const response = await this.getBodyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Lookup
+   */
+  async lookupRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.externalUrl !== void 0) {
+      queryParameters["external_url"] = requestParameters.externalUrl;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/lookup`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Lookup
+   */
+  async lookup(requestParameters = {}, initOverrides) {
+    const response = await this.lookupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Remove Polar Badge
+   */
+  async removePolarBadgeRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling removePolarBadge.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}/remove_badge`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Remove Polar Badge
+   */
+  async removePolarBadge(requestParameters, initOverrides) {
+    const response = await this.removePolarBadgeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search issues.
+   * Search issues (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling search.");
+    }
+    if (requestParameters.organizationName === null || requestParameters.organizationName === void 0) {
+      throw new RequiredError("organizationName", "Required parameter requestParameters.organizationName was null or undefined when calling search.");
+    }
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    if (requestParameters.sort !== void 0) {
+      queryParameters["sort"] = requestParameters.sort;
+    }
+    if (requestParameters.havePledge !== void 0) {
+      queryParameters["have_pledge"] = requestParameters.havePledge;
+    }
+    if (requestParameters.haveBadge !== void 0) {
+      queryParameters["have_badge"] = requestParameters.haveBadge;
+    }
+    if (requestParameters.githubMilestoneNumber !== void 0) {
+      queryParameters["github_milestone_number"] = requestParameters.githubMilestoneNumber;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search issues.
+   * Search issues (Public API)
+   */
+  async search(requestParameters, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update issue. Requires authentication.
+   * Update issue. (Public API)
+   */
+  async updateRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling update.");
+    }
+    if (requestParameters.updateIssue === null || requestParameters.updateIssue === void 0) {
+      throw new RequiredError("updateIssue", "Required parameter requestParameters.updateIssue was null or undefined when calling update.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/issues/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.updateIssue
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update issue. Requires authentication.
+   * Update issue. (Public API)
+   */
+  async update(requestParameters, initOverrides) {
+    const response = await this.updateRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/MagicLinkApi.ts
+var MagicLinkApi = class extends BaseAPI {
+  /**
+   * Authenticate Magic Link
+   */
+  async authenticateMagicLinkRaw(requestParameters, initOverrides) {
+    if (requestParameters.token === null || requestParameters.token === void 0) {
+      throw new RequiredError("token", "Required parameter requestParameters.token was null or undefined when calling authenticateMagicLink.");
+    }
+    const queryParameters = {};
+    if (requestParameters.token !== void 0) {
+      queryParameters["token"] = requestParameters.token;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/magic_link/authenticate`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Authenticate Magic Link
+   */
+  async authenticateMagicLink(requestParameters, initOverrides) {
+    const response = await this.authenticateMagicLinkRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Request Magic Link
+   */
+  async requestMagicLinkRaw(requestParameters, initOverrides) {
+    if (requestParameters.magicLinkRequest === null || requestParameters.magicLinkRequest === void 0) {
+      throw new RequiredError("magicLinkRequest", "Required parameter requestParameters.magicLinkRequest was null or undefined when calling requestMagicLink.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/magic_link/request`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.magicLinkRequest
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Request Magic Link
+   */
+  async requestMagicLink(requestParameters, initOverrides) {
+    const response = await this.requestMagicLinkRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/NotificationsApi.ts
+var NotificationsApi = class extends BaseAPI {
+  /**
+   * Get
+   */
+  async getRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/notifications`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get
+   */
+  async get(initOverrides) {
+    const response = await this.getRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Mark Read
+   */
+  async markReadRaw(requestParameters, initOverrides) {
+    if (requestParameters.notificationsMarkRead === null || requestParameters.notificationsMarkRead === void 0) {
+      throw new RequiredError("notificationsMarkRead", "Required parameter requestParameters.notificationsMarkRead was null or undefined when calling markRead.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/notifications/read`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.notificationsMarkRead
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Mark Read
+   */
+  async markRead(requestParameters, initOverrides) {
+    const response = await this.markReadRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/OrganizationsApi.ts
+var OrganizationsApi = class extends BaseAPI {
+  /**
+   * Get organization
+   * Get organization (Public API)
+   */
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling get.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get organization
+   * Get organization (Public API)
+   */
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get badge settings (Internal API)
+   */
+  async getBadgeSettingsRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling getBadgeSettings.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations/{id}/badge_settings`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get badge settings (Internal API)
+   */
+  async getBadgeSettings(requestParameters, initOverrides) {
+    const response = await this.getBadgeSettingsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * List organizations that the authenticated user is a member of. Requires authentication.
+   * List organizations (Public API)
+   */
+  async listRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * List organizations that the authenticated user is a member of. Requires authentication.
+   * List organizations (Public API)
+   */
+  async list(initOverrides) {
+    const response = await this.listRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Lookup organization. Like search but returns at only one organization.
+   * Lookup organization (Public API)
+   */
+  async lookupRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations/lookup`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Lookup organization. Like search but returns at only one organization.
+   * Lookup organization (Public API)
+   */
+  async lookup(requestParameters = {}, initOverrides) {
+    const response = await this.lookupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search organizations.
+   * Search organizations (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search organizations.
+   * Search organizations (Public API)
+   */
+  async search(requestParameters = {}, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update badge settings (Internal API)
+   */
+  async updateBadgeSettingsRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling updateBadgeSettings.");
+    }
+    if (requestParameters.organizationBadgeSettingsUpdate === null || requestParameters.organizationBadgeSettingsUpdate === void 0) {
+      throw new RequiredError("organizationBadgeSettingsUpdate", "Required parameter requestParameters.organizationBadgeSettingsUpdate was null or undefined when calling updateBadgeSettings.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/organizations/{id}/badge_settings`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.organizationBadgeSettingsUpdate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update badge settings (Internal API)
+   */
+  async updateBadgeSettings(requestParameters, initOverrides) {
+    const response = await this.updateBadgeSettingsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/PaymentMethodsApi.ts
+var PaymentMethodsApi = class extends BaseAPI {
+  /**
+   * Detach
+   */
+  async detachRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling detach.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/payment_methods/{id}/detach`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Detach
+   */
+  async detach(requestParameters, initOverrides) {
+    const response = await this.detachRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * List
+   */
+  async listRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/payment_methods`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * List
+   */
+  async list(initOverrides) {
+    const response = await this.listRaw(initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/PersonalAccessTokenApi.ts
+var PersonalAccessTokenApi = class extends BaseAPI {
+  /**
+   * Delete a personal access tokens. Requires authentication.
+   * Delete a personal access tokens (Public API)
+   */
+  async _deleteRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling _delete.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/personal_access_tokens/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Delete a personal access tokens. Requires authentication.
+   * Delete a personal access tokens (Public API)
+   */
+  async _delete(requestParameters, initOverrides) {
+    const response = await this._deleteRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Create a new personal access token. Requires authentication.
+   * Create a new personal access token (Public API)
+   */
+  async createRaw(requestParameters, initOverrides) {
+    if (requestParameters.createPersonalAccessToken === null || requestParameters.createPersonalAccessToken === void 0) {
+      throw new RequiredError("createPersonalAccessToken", "Required parameter requestParameters.createPersonalAccessToken was null or undefined when calling create.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/personal_access_tokens`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.createPersonalAccessToken
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create a new personal access token. Requires authentication.
+   * Create a new personal access token (Public API)
+   */
+  async create(requestParameters, initOverrides) {
+    const response = await this.createRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * List personal access tokens. Requires authentication.
+   * List personal access tokens (Public API)
+   */
+  async listRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/personal_access_tokens`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * List personal access tokens. Requires authentication.
+   * List personal access tokens (Public API)
+   */
+  async list(initOverrides) {
+    const response = await this.listRaw(initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/PledgesApi.ts
+var PledgesApi = class extends BaseAPI {
+  /**
+   * Creates a pledge from a payment intent
+   * Create
+   */
+  async createRaw(requestParameters, initOverrides) {
+    if (requestParameters.createPledgeFromPaymentIntent === null || requestParameters.createPledgeFromPaymentIntent === void 0) {
+      throw new RequiredError("createPledgeFromPaymentIntent", "Required parameter requestParameters.createPledgeFromPaymentIntent was null or undefined when calling create.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.createPledgeFromPaymentIntent
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Creates a pledge from a payment intent
+   * Create
+   */
+  async create(requestParameters, initOverrides) {
+    const response = await this.createRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates an invoice for pay_on_completion pledges
+   * Create Invoice
+   */
+  async createInvoiceRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling createInvoice.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/{id}/create_invoice`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Creates an invoice for pay_on_completion pledges
+   * Create Invoice
+   */
+  async createInvoice(requestParameters, initOverrides) {
+    const response = await this.createInvoiceRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates a pay_on_completion type of pledge
+   * Create Pay On Completion
+   */
+  async createPayOnCompletionRaw(requestParameters, initOverrides) {
+    if (requestParameters.createPledgePayLater === null || requestParameters.createPledgePayLater === void 0) {
+      throw new RequiredError("createPledgePayLater", "Required parameter requestParameters.createPledgePayLater was null or undefined when calling createPayOnCompletion.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/pay_on_completion`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.createPledgePayLater
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Creates a pay_on_completion type of pledge
+   * Create Pay On Completion
+   */
+  async createPayOnCompletion(requestParameters, initOverrides) {
+    const response = await this.createPayOnCompletionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Create Payment Intent
+   */
+  async createPaymentIntentRaw(requestParameters, initOverrides) {
+    if (requestParameters.pledgeStripePaymentIntentCreate === null || requestParameters.pledgeStripePaymentIntentCreate === void 0) {
+      throw new RequiredError("pledgeStripePaymentIntentCreate", "Required parameter requestParameters.pledgeStripePaymentIntentCreate was null or undefined when calling createPaymentIntent.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/payment_intent`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.pledgeStripePaymentIntentCreate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create Payment Intent
+   */
+  async createPaymentIntent(requestParameters, initOverrides) {
+    const response = await this.createPaymentIntentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Dispute Pledge
+   */
+  async disputePledgeRaw(requestParameters, initOverrides) {
+    if (requestParameters.pledgeId === null || requestParameters.pledgeId === void 0) {
+      throw new RequiredError("pledgeId", "Required parameter requestParameters.pledgeId was null or undefined when calling disputePledge.");
+    }
+    if (requestParameters.reason === null || requestParameters.reason === void 0) {
+      throw new RequiredError("reason", "Required parameter requestParameters.reason was null or undefined when calling disputePledge.");
+    }
+    const queryParameters = {};
+    if (requestParameters.reason !== void 0) {
+      queryParameters["reason"] = requestParameters.reason;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/{pledge_id}/dispute`.replace(`{${"pledge_id"}}`, encodeURIComponent(String(requestParameters.pledgeId))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Dispute Pledge
+   */
+  async disputePledge(requestParameters, initOverrides) {
+    const response = await this.disputePledgeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get a pledge. Requires authentication.
+   * Get pledge (Public API)
+   */
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling get.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get a pledge. Requires authentication.
+   * Get pledge (Public API)
+   */
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search pledges. Requires authentication. The user can only read pledges that they have made (personally or via an organization) or received (to organizations that they are a member of).
+   * Search pledges (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    if (requestParameters.issueId !== void 0) {
+      queryParameters["issue_id"] = requestParameters.issueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search pledges. Requires authentication. The user can only read pledges that they have made (personally or via an organization) or received (to organizations that they are a member of).
+   * Search pledges (Public API)
+   */
+  async search(requestParameters = {}, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get summary of pledges for resource.
+   * Get pledges summary (Public API)
+   */
+  async summaryRaw(requestParameters, initOverrides) {
+    if (requestParameters.issueId === null || requestParameters.issueId === void 0) {
+      throw new RequiredError("issueId", "Required parameter requestParameters.issueId was null or undefined when calling summary.");
+    }
+    const queryParameters = {};
+    if (requestParameters.issueId !== void 0) {
+      queryParameters["issue_id"] = requestParameters.issueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/summary`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get summary of pledges for resource.
+   * Get pledges summary (Public API)
+   */
+  async summary(requestParameters, initOverrides) {
+    const response = await this.summaryRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update Payment Intent
+   */
+  async updatePaymentIntentRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling updatePaymentIntent.");
+    }
+    if (requestParameters.pledgeStripePaymentIntentUpdate === null || requestParameters.pledgeStripePaymentIntentUpdate === void 0) {
+      throw new RequiredError("pledgeStripePaymentIntentUpdate", "Required parameter requestParameters.pledgeStripePaymentIntentUpdate was null or undefined when calling updatePaymentIntent.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pledges/payment_intent/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.pledgeStripePaymentIntentUpdate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update Payment Intent
+   */
+  async updatePaymentIntent(requestParameters, initOverrides) {
+    const response = await this.updatePaymentIntentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/PullRequestsApi.ts
+var PullRequestsApi = class extends BaseAPI {
+  /**
+   * Search pull requests.
+   * Search pull requests (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.referencesIssueId !== void 0) {
+      queryParameters["references_issue_id"] = requestParameters.referencesIssueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/pull_requests/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search pull requests.
+   * Search pull requests (Public API)
+   */
+  async search(requestParameters = {}, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/RepositoriesApi.ts
+var RepositoriesApi = class extends BaseAPI {
+  /**
+   * Get a repository
+   * Get a repository (Public API)
+   */
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling get.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/repositories/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get a repository
+   * Get a repository (Public API)
+   */
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * List repositories in organizations that the authenticated user is a member of. Requires authentication.
+   * List repositories (Public API)
+   */
+  async listRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/repositories`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * List repositories in organizations that the authenticated user is a member of. Requires authentication.
+   * List repositories (Public API)
+   */
+  async list(initOverrides) {
+    const response = await this.listRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Lookup repositories. Like search but returns at only one repository.
+   * Lookup repositories (Public API)
+   */
+  async lookupRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling lookup.");
+    }
+    if (requestParameters.organizationName === null || requestParameters.organizationName === void 0) {
+      throw new RequiredError("organizationName", "Required parameter requestParameters.organizationName was null or undefined when calling lookup.");
+    }
+    if (requestParameters.repositoryName === null || requestParameters.repositoryName === void 0) {
+      throw new RequiredError("repositoryName", "Required parameter requestParameters.repositoryName was null or undefined when calling lookup.");
+    }
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/repositories/lookup`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Lookup repositories. Like search but returns at only one repository.
+   * Lookup repositories (Public API)
+   */
+  async lookup(requestParameters, initOverrides) {
+    const response = await this.lookupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search repositories.
+   * Search repositories (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling search.");
+    }
+    if (requestParameters.organizationName === null || requestParameters.organizationName === void 0) {
+      throw new RequiredError("organizationName", "Required parameter requestParameters.organizationName was null or undefined when calling search.");
+    }
+    const queryParameters = {};
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/repositories/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search repositories.
+   * Search repositories (Public API)
+   */
+  async search(requestParameters, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/RewardsApi.ts
+var RewardsApi = class extends BaseAPI {
+  /**
+   * Search rewards.
+   * Search rewards (Public API)
+   */
+  async searchRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters.pledgesToOrganization !== void 0) {
+      queryParameters["pledges_to_organization"] = requestParameters.pledgesToOrganization;
+    }
+    if (requestParameters.rewardsToUser !== void 0) {
+      queryParameters["rewards_to_user"] = requestParameters.rewardsToUser;
+    }
+    if (requestParameters.rewardsToOrg !== void 0) {
+      queryParameters["rewards_to_org"] = requestParameters.rewardsToOrg;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/rewards/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search rewards.
+   * Search rewards (Public API)
+   */
+  async search(requestParameters = {}, initOverrides) {
+    const response = await this.searchRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get summary of rewards for resource.
+   * Get rewards summary (Public API)
+   */
+  async summaryRaw(requestParameters, initOverrides) {
+    if (requestParameters.issueId === null || requestParameters.issueId === void 0) {
+      throw new RequiredError("issueId", "Required parameter requestParameters.issueId was null or undefined when calling summary.");
+    }
+    const queryParameters = {};
+    if (requestParameters.issueId !== void 0) {
+      queryParameters["issue_id"] = requestParameters.issueId;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/rewards/summary`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get summary of rewards for resource.
+   * Get rewards summary (Public API)
+   */
+  async summary(requestParameters, initOverrides) {
+    const response = await this.summaryRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/StreamApi.ts
+var StreamApi = class extends BaseAPI {
+  /**
+   * User Org Repo Stream
+   */
+  async userOrgRepoStreamRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling userOrgRepoStream.");
+    }
+    if (requestParameters.orgName === null || requestParameters.orgName === void 0) {
+      throw new RequiredError("orgName", "Required parameter requestParameters.orgName was null or undefined when calling userOrgRepoStream.");
+    }
+    if (requestParameters.repoName === null || requestParameters.repoName === void 0) {
+      throw new RequiredError("repoName", "Required parameter requestParameters.repoName was null or undefined when calling userOrgRepoStream.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/{platform}/{org_name}/{repo_name}/stream`.replace(`{${"platform"}}`, encodeURIComponent(String(requestParameters.platform))).replace(`{${"org_name"}}`, encodeURIComponent(String(requestParameters.orgName))).replace(`{${"repo_name"}}`, encodeURIComponent(String(requestParameters.repoName))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * User Org Repo Stream
+   */
+  async userOrgRepoStream(requestParameters, initOverrides) {
+    const response = await this.userOrgRepoStreamRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * User Org Stream
+   */
+  async userOrgStreamRaw(requestParameters, initOverrides) {
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling userOrgStream.");
+    }
+    if (requestParameters.orgName === null || requestParameters.orgName === void 0) {
+      throw new RequiredError("orgName", "Required parameter requestParameters.orgName was null or undefined when calling userOrgStream.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/{platform}/{org_name}/stream`.replace(`{${"platform"}}`, encodeURIComponent(String(requestParameters.platform))).replace(`{${"org_name"}}`, encodeURIComponent(String(requestParameters.orgName))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * User Org Stream
+   */
+  async userOrgStream(requestParameters, initOverrides) {
+    const response = await this.userOrgStreamRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * User Stream
+   */
+  async userStreamRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/user/stream`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * User Stream
+   */
+  async userStream(initOverrides) {
+    const response = await this.userStreamRaw(initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/SubscriptionsApi.ts
+var SubscriptionsApi = class extends BaseAPI {
+  /**
+   * Archive Subscription Tier
+   */
+  async archiveSubscriptionTierRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling archiveSubscriptionTier.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/tiers/{id}/archive`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Archive Subscription Tier
+   */
+  async archiveSubscriptionTier(requestParameters, initOverrides) {
+    const response = await this.archiveSubscriptionTierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Create Subscription Group
+   */
+  async createSubscriptionGroupRaw(requestParameters, initOverrides) {
+    if (requestParameters.subscriptionGroupCreate === null || requestParameters.subscriptionGroupCreate === void 0) {
+      throw new RequiredError("subscriptionGroupCreate", "Required parameter requestParameters.subscriptionGroupCreate was null or undefined when calling createSubscriptionGroup.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/groups/`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.subscriptionGroupCreate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create Subscription Group
+   */
+  async createSubscriptionGroup(requestParameters, initOverrides) {
+    const response = await this.createSubscriptionGroupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Create Subscription Tier
+   */
+  async createSubscriptionTierRaw(requestParameters, initOverrides) {
+    if (requestParameters.subscriptionTierCreate === null || requestParameters.subscriptionTierCreate === void 0) {
+      throw new RequiredError("subscriptionTierCreate", "Required parameter requestParameters.subscriptionTierCreate was null or undefined when calling createSubscriptionTier.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/tiers/`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.subscriptionTierCreate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create Subscription Tier
+   */
+  async createSubscriptionTier(requestParameters, initOverrides) {
+    const response = await this.createSubscriptionTierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get Subscription Tier Subscribe Url
+   */
+  async getSubscriptionTierSubscribeUrlRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling getSubscriptionTierSubscribeUrl.");
+    }
+    if (requestParameters.successUrl === null || requestParameters.successUrl === void 0) {
+      throw new RequiredError("successUrl", "Required parameter requestParameters.successUrl was null or undefined when calling getSubscriptionTierSubscribeUrl.");
+    }
+    const queryParameters = {};
+    if (requestParameters.successUrl !== void 0) {
+      queryParameters["success_url"] = requestParameters.successUrl;
+    }
+    if (requestParameters.customerEmail !== void 0) {
+      queryParameters["customer_email"] = requestParameters.customerEmail;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/tiers/{id}/subscribe`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get Subscription Tier Subscribe Url
+   */
+  async getSubscriptionTierSubscribeUrl(requestParameters, initOverrides) {
+    const response = await this.getSubscriptionTierSubscribeUrlRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Search Subscription Groups
+   */
+  async searchSubscriptionGroupsRaw(requestParameters, initOverrides) {
+    if (requestParameters.organizationName === null || requestParameters.organizationName === void 0) {
+      throw new RequiredError("organizationName", "Required parameter requestParameters.organizationName was null or undefined when calling searchSubscriptionGroups.");
+    }
+    if (requestParameters.platform === null || requestParameters.platform === void 0) {
+      throw new RequiredError("platform", "Required parameter requestParameters.platform was null or undefined when calling searchSubscriptionGroups.");
+    }
+    const queryParameters = {};
+    if (requestParameters.organizationName !== void 0) {
+      queryParameters["organization_name"] = requestParameters.organizationName;
+    }
+    if (requestParameters.repositoryName !== void 0) {
+      queryParameters["repository_name"] = requestParameters.repositoryName;
+    }
+    if (requestParameters.directOrganization !== void 0) {
+      queryParameters["direct_organization"] = requestParameters.directOrganization;
+    }
+    if (requestParameters.platform !== void 0) {
+      queryParameters["platform"] = requestParameters.platform;
+    }
+    if (requestParameters.page !== void 0) {
+      queryParameters["page"] = requestParameters.page;
+    }
+    if (requestParameters.limit !== void 0) {
+      queryParameters["limit"] = requestParameters.limit;
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/groups/search`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Search Subscription Groups
+   */
+  async searchSubscriptionGroups(requestParameters, initOverrides) {
+    const response = await this.searchSubscriptionGroupsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update Subscription Group
+   */
+  async updateSubscriptionGroupRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling updateSubscriptionGroup.");
+    }
+    if (requestParameters.subscriptionGroupUpdate === null || requestParameters.subscriptionGroupUpdate === void 0) {
+      throw new RequiredError("subscriptionGroupUpdate", "Required parameter requestParameters.subscriptionGroupUpdate was null or undefined when calling updateSubscriptionGroup.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/groups/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.subscriptionGroupUpdate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update Subscription Group
+   */
+  async updateSubscriptionGroup(requestParameters, initOverrides) {
+    const response = await this.updateSubscriptionGroupRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update Subscription Tier
+   */
+  async updateSubscriptionTierRaw(requestParameters, initOverrides) {
+    if (requestParameters.id === null || requestParameters.id === void 0) {
+      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling updateSubscriptionTier.");
+    }
+    if (requestParameters.subscriptionTierUpdate === null || requestParameters.subscriptionTierUpdate === void 0) {
+      throw new RequiredError("subscriptionTierUpdate", "Required parameter requestParameters.subscriptionTierUpdate was null or undefined when calling updateSubscriptionTier.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/subscriptions/tiers/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.subscriptionTierUpdate
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update Subscription Tier
+   */
+  async updateSubscriptionTier(requestParameters, initOverrides) {
+    const response = await this.updateSubscriptionTierRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/apis/UsersApi.ts
+var UsersApi = class extends BaseAPI {
+  /**
+   * Create Stripe Customer Portal
+   */
+  async createStripeCustomerPortalRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/users/me/stripe_customer_portal`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create Stripe Customer Portal
+   */
+  async createStripeCustomerPortal(initOverrides) {
+    const response = await this.createStripeCustomerPortalRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Create Token
+   */
+  async createTokenRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/users/me/token`,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Create Token
+   */
+  async createToken(initOverrides) {
+    const response = await this.createTokenRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Get Authenticated
+   */
+  async getAuthenticatedRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/users/me`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Get Authenticated
+   */
+  async getAuthenticated(initOverrides) {
+    const response = await this.getAuthenticatedRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Logout
+   */
+  async logoutRaw(initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/users/logout`,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Logout
+   */
+  async logout(initOverrides) {
+    const response = await this.logoutRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Update Preferences
+   */
+  async updatePreferencesRaw(requestParameters, initOverrides) {
+    if (requestParameters.userUpdateSettings === null || requestParameters.userUpdateSettings === void 0) {
+      throw new RequiredError("userUpdateSettings", "Required parameter requestParameters.userUpdateSettings was null or undefined when calling updatePreferences.");
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("HTTPBearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const response = await this.request({
+      path: `/api/v1/users/me`,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters.userUpdateSettings
+    }, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update Preferences
+   */
+  async updatePreferences(requestParameters, initOverrides) {
+    const response = await this.updatePreferencesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/client/models/index.ts
+var AccountType = {
+  STRIPE: "stripe",
+  OPEN_COLLECTIVE: "open_collective"
+};
+var BackofficeBadgeActionEnum = {
+  EMBED: "embed",
+  REMOVE: "remove"
+};
+var BackofficeBadgeResponseActionEnum = {
+  EMBED: "embed",
+  REMOVE: "remove"
+};
+var GithubBadgeReadBadgeTypeEnum = {
+  PLEDGE: "pledge"
+};
+var InstallationCreatePlatformEnum = {
+  GITHUB: "github"
+};
+var IssueStateEnum = {
+  OPEN: "OPEN",
+  CLOSED: "CLOSED"
+};
+var IssueListType = {
+  ISSUES: "issues",
+  DEPENDENCIES: "dependencies"
+};
+var IssueReferenceType = {
+  PULL_REQUEST: "pull_request",
+  EXTERNAL_GITHUB_PULL_REQUEST: "external_github_pull_request",
+  EXTERNAL_GITHUB_COMMIT: "external_github_commit"
+};
+var IssueSortBy = {
+  NEWEST: "newest",
+  RECENTLY_UPDATED: "recently_updated",
+  LEAST_RECENTLY_UPDATED: "least_recently_updated",
+  PLEDGED_AMOUNT_DESC: "pledged_amount_desc",
+  RELEVANCE: "relevance",
+  DEPENDENCIES_DEFAULT: "dependencies_default",
+  ISSUES_DEFAULT: "issues_default",
+  MOST_ENGAGEMENT: "most_engagement",
+  MOST_POSITIVE_REACTIONS: "most_positive_reactions",
+  FUNDING_GOAL_DESC_AND_MOST_POSITIVE_REACTIONS: "funding_goal_desc_and_most_positive_reactions"
+};
+var IssueStatus = {
+  BACKLOG: "backlog",
+  TRIAGED: "triaged",
+  IN_PROGRESS: "in_progress",
+  PULL_REQUEST: "pull_request",
+  CLOSED: "closed",
+  BUILDING: "building"
+};
+var ListFundingSortBy = {
+  OLDEST: "oldest",
+  NEWEST: "newest",
+  MOST_FUNDED: "most_funded",
+  MOST_ENGAGEMENT: "most_engagement"
+};
+var NotificationType = {
+  MAINTAINER_PLEDGE_PAID_NOTIFICATION: "MaintainerPledgePaidNotification",
+  MAINTAINER_PLEDGE_CONFIRMATION_PENDING_NOTIFICATION: "MaintainerPledgeConfirmationPendingNotification",
+  MAINTAINER_PLEDGE_PENDING_NOTIFICATION: "MaintainerPledgePendingNotification",
+  MAINTAINER_PLEDGE_CREATED_NOTIFICATION: "MaintainerPledgeCreatedNotification",
+  PLEDGER_PLEDGE_PENDING_NOTIFICATION: "PledgerPledgePendingNotification",
+  REWARD_PAID_NOTIFICATION: "RewardPaidNotification",
+  MAINTAINER_PLEDGED_ISSUE_CONFIRMATION_PENDING_NOTIFICATION: "MaintainerPledgedIssueConfirmationPendingNotification",
+  MAINTAINER_PLEDGED_ISSUE_PENDING_NOTIFICATION: "MaintainerPledgedIssuePendingNotification"
+};
+var PaymentMethodTypeEnum = {
+  CARD: "card"
+};
+var Platforms = {
+  GITHUB: "github"
+};
+var PledgeState = {
+  INITIATED: "initiated",
+  CREATED: "created",
+  PENDING: "pending",
+  REFUNDED: "refunded",
+  DISPUTED: "disputed",
+  CHARGE_DISPUTED: "charge_disputed"
+};
+var PledgeStripePaymentIntentCreateSetupFutureUsageEnum = {
+  ON_SESSION: "on_session"
+};
+var PledgeStripePaymentIntentUpdateSetupFutureUsageEnum = {
+  ON_SESSION: "on_session"
+};
+var PledgeType = {
+  UPFRONT: "pay_upfront",
+  ON_COMPLETION: "pay_on_completion",
+  DIRECTLY: "pay_directly"
+};
+var RewardState = {
+  PENDING: "pending",
+  PAID: "paid"
+};
+var UserSignupType = {
+  MAINTAINER: "maintainer",
+  BACKER: "backer"
+};
+var Visibility = {
+  PUBLIC: "public",
+  PRIVATE: "private"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountType,
+  AccountsApi,
+  BASE_PATH,
+  BackofficeApi,
+  BackofficeBadgeActionEnum,
+  BackofficeBadgeResponseActionEnum,
+  BaseAPI,
+  BlobApiResponse,
+  COLLECTION_FORMATS,
+  Configuration,
+  DashboardApi,
+  DefaultConfig,
+  ExtensionApi,
+  FetchError,
+  FundingApi,
+  GetBadgeSettingsBadgeTypeEnum,
+  GithubBadgeReadBadgeTypeEnum,
+  HealthApi,
+  InstallationCreatePlatformEnum,
+  IntegrationsApi,
+  IssueListType,
+  IssueReferenceType,
+  IssueSortBy,
+  IssueStateEnum,
+  IssueStatus,
+  IssuesApi,
+  JSONApiResponse,
+  ListFundingSortBy,
+  MagicLinkApi,
+  NotificationType,
+  NotificationsApi,
+  OrganizationsApi,
+  PaymentMethodTypeEnum,
+  PaymentMethodsApi,
+  PersonalAccessTokenApi,
+  Platforms,
+  PledgeState,
+  PledgeStripePaymentIntentCreateSetupFutureUsageEnum,
+  PledgeStripePaymentIntentUpdateSetupFutureUsageEnum,
+  PledgeType,
+  PledgesApi,
+  PolarAPI,
+  PullRequestsApi,
+  RepositoriesApi,
+  RequiredError,
+  ResponseError,
+  RewardState,
+  RewardsApi,
+  StreamApi,
+  SubscriptionsApi,
+  TextApiResponse,
+  UserSignupType,
+  UsersApi,
+  Visibility,
+  VoidApiResponse,
+  canConsumeForm,
+  querystring
+});