@coinlist-co/react 0.3.0 → 0.4.0

package/dist/chunk-NC45IO63.js

@@ -0,0 +1,777 @@
+// src/shared/api/pagination.ts
+var Cursor = (value) => value;
+async function fetchAllPages(fetchPage, baseParams) {
+  const items = [];
+  let cursor = null;
+  do {
+    const params = {
+      ...baseParams ?? {},
+      after: cursor ?? void 0
+    };
+    const page = await fetchPage(params);
+    items.push(...page.data);
+    cursor = page.startingAfter;
+  } while (cursor);
+  return items;
+}
+var PaginatedResponse = {
+  fromDto: (dto, itemMapper) => ({
+    data: dto.data.map(itemMapper),
+    startingAfter: dto.starting_after ? Cursor(dto.starting_after) : null,
+    startingBefore: dto.starting_before ? Cursor(dto.starting_before) : null
+  })
+};
+var PaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = {};
+    if (params.after) {
+      queryParams.starting_after = params.after;
+    }
+    if (params.before) {
+      queryParams.starting_before = params.before;
+    }
+    if (params.limit) {
+      queryParams.limit = params.limit;
+    }
+    return queryParams;
+  }
+};
+
+// src/shared/utils.ts
+async function sha256(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  return crypto.subtle.digest("SHA-256", buffer);
+}
+function arrayBufferToBase64Url(buffer, padding = true) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  let base64 = btoa(binary);
+  base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+  if (!padding) {
+    base64 = base64.replace(/=+$/, "");
+  }
+  return base64;
+}
+function generateSecureRandomBase64Url(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  const buffer = bytes.buffer;
+  return arrayBufferToBase64Url(buffer, false);
+}
+function getUUIDv4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+}
+function notBlankStringOrNull(value) {
+  if (value?.trim()) {
+    return value;
+  } else {
+    return null;
+  }
+}
+
+// src/shared/types/offer.ts
+var OfferId = (value) => value;
+var OfferSlug = (value) => value;
+var Offer = {
+  fromDto: (dto) => ({
+    id: OfferId(dto.id),
+    slug: OfferSlug(dto.slug),
+    tagline: notBlankStringOrNull(dto.tagline),
+    bannerUrl: notBlankStringOrNull(dto.banner_url),
+    logoUrl: notBlankStringOrNull(dto.logo_url),
+    startsAt: new Date(dto.starts_at),
+    endsAt: new Date(dto.ends_at)
+  })
+};
+
+// src/shared/types/asset.ts
+var AssetId = (value) => value;
+var AssetCode = (value) => value;
+var Asset = {
+  fromDto: (dto) => ({
+    id: AssetId(dto.id),
+    code: AssetCode(dto.code),
+    name: dto.name,
+    fractionalDigits: dto.fractional_digits
+  })
+};
+
+// src/shared/types/offer-detail.ts
+var OfferOptionId = (value) => value;
+var OfferOptionSlug = (value) => value;
+var OfferDetail = {
+  fromDto: (dto) => {
+    if (!Array.isArray(dto.funding_assets)) {
+      throw new Error(`funding_assets must be an array`);
+    }
+    if (!Array.isArray(dto.options)) {
+      throw new Error(`options must be an array`);
+    }
+    if (!Array.isArray(dto.terms)) {
+      throw new Error(`terms must be an array`);
+    }
+    if (!Array.isArray(dto.links)) {
+      throw new Error(`links must be an array`);
+    }
+    if (!Array.isArray(dto.faqs)) {
+      throw new Error(`faqs must be an array`);
+    }
+    if (!Array.isArray(dto.milestones)) {
+      throw new Error(`milestones must be an array`);
+    }
+    return {
+      id: OfferId(dto.id),
+      slug: OfferSlug(dto.slug),
+      name: dto.name,
+      asset: Asset.fromDto(dto.asset),
+      fundingAssets: dto.funding_assets.map(Asset.fromDto),
+      about: notBlankStringOrNull(dto.about),
+      tagline: notBlankStringOrNull(dto.tagline),
+      bannerUrl: notBlankStringOrNull(dto.banner_url),
+      logoUrl: notBlankStringOrNull(dto.logo_url),
+      category: notBlankStringOrNull(dto.category),
+      startsAt: new Date(dto.starts_at),
+      endsAt: new Date(dto.ends_at),
+      faqs: dto.faqs.map(FaqItem.fromDto),
+      links: dto.links.map(Link.fromDto),
+      milestones: dto.milestones.map(Milestone.fromDto),
+      options: dto.options.map(OfferOption.fromDto),
+      terms: dto.terms.map(TermItem.fromDto)
+    };
+  }
+};
+var OfferOption = {
+  fromDto: (dto) => ({
+    id: OfferOptionId(dto.id),
+    slug: OfferOptionSlug(dto.slug),
+    bidIncrement: dto.bid_increment,
+    floorPriceUsd: dto.floor_price_usd,
+    minimumPurchaseUsd: dto.minimum_purchase_usd,
+    priceUsd: dto.price_usd,
+    saleAgreementUrl: notBlankStringOrNull(dto.sale_agreement_url),
+    totalTokenSupply: dto.total_token_supply
+  })
+};
+var FaqItem = {
+  fromDto: (dto) => ({
+    question: notBlankStringOrNull(dto.question),
+    answer: notBlankStringOrNull(dto.answer)
+  })
+};
+var Link = {
+  fromDto: (dto) => ({
+    label: notBlankStringOrNull(dto.label),
+    url: notBlankStringOrNull(dto.url)
+  })
+};
+var TermItem = {
+  fromDto: (dto) => ({
+    key: notBlankStringOrNull(dto.key),
+    value: notBlankStringOrNull(dto.value)
+  })
+};
+var Milestone = {
+  fromDto: (dto) => ({
+    name: notBlankStringOrNull(dto.name),
+    schedule: notBlankStringOrNull(dto.schedule),
+    status: dto.status
+  })
+};
+
+// src/shared/types/participation.ts
+var ParticipationId = (value) => value;
+var Blockchain = (value) => value;
+var WalletAddress = (value) => value;
+var ParticipationsPaginationParams = {
+  toQueryParams: (params) => {
+    const queryParams = PaginationParams.toQueryParams(params);
+    if (params.offerId) {
+      queryParams["filters[0][field]"] = "offer_id";
+      queryParams["filters[0][op]"] = "==";
+      queryParams["filters[0][value]"] = params.offerId;
+    }
+    return queryParams;
+  }
+};
+var Participation = {
+  /** Maps API DTO shape into the SDK participation domain model. */
+  fromDto: (dto) => {
+    const walletAddress = notBlankStringOrNull(dto.wallet_address);
+    return {
+      id: ParticipationId(dto.id),
+      offerId: OfferId(dto.offer_id),
+      offerOptionId: OfferOptionId(dto.offer_option_id),
+      status: dto.status,
+      amount: dto.amount,
+      displayAmount: dto.amount_string,
+      asset: Asset.fromDto(dto.asset),
+      chain: Blockchain(dto.chain),
+      insertedAt: dto.inserted_at ? new Date(dto.inserted_at) : null,
+      updatedAt: dto.updated_at ? new Date(dto.updated_at) : null,
+      walletAddress: walletAddress ? WalletAddress(walletAddress) : null
+    };
+  }
+};
+var CreateParticipationParams = {
+  /** Maps participation creation params into API DTO payload. */
+  toDto: (params) => ({
+    offer_id: params.offerId,
+    offer_option_id: params.offerOptionId,
+    chain: params.chain,
+    wallet_address: params.walletAddress,
+    amount: params.amount,
+    asset_id: params.assetId,
+    approval_transaction_hash: params.approvalTransactionHash
+  })
+};
+
+// src/shared/types/requirement.ts
+var RequirementId = (value) => value;
+var Requirement = {
+  fromDto: (dto) => ({
+    id: RequirementId(dto.id),
+    type: dto.type,
+    details: dto.details
+  })
+};
+var RequirementStatusInfo = {
+  fromStatusesDto: (dto) => Object.entries(dto.statuses).map(([id, status]) => ({
+    id: RequirementId(id),
+    status
+  }))
+};
+
+// src/shared/types/errors.ts
+var NotImplementedError = class extends Error {
+  constructor(message = "Not implemented yet") {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor(message = "The user is not authenticated. Go through the OAuth flow first!") {
+    super(message);
+    this.name = "NotAuthenticatedError";
+  }
+};
+
+// src/shared/types/oauth.ts
+var AuthorizationCode = (value) => value;
+var CodeVerifier = (value) => value;
+var CodeChallenge = (value) => value;
+var RedirectUri = (value) => value;
+var ClientId = (value) => value;
+var ClientSecret = (value) => value;
+
+// src/shared/api/frontline/index.ts
+var PUBLIC_API_BASE_URL = "https://api.coinlist.co";
+var HEADER_API_VERSION = "X-API-Version";
+var HEADER_USER_AGENT = "User-Agent";
+var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+var API_VERSION = "2025-10-17";
+var COINLIST_BASE_URL = "https://coinlist.co";
+var OAUTH_PAGE_PATH = "/oauth/authorize";
+var SUPPORT_NEW_TICKET_URL = "https://support.coinlist.co/support/tickets/new";
+var VERIFY_IDENTITY_PATH = "/verify-identity";
+var VERIFY_IDENTITY_VERIFIED_PATH = "/verify-identity/identity_verified";
+var VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH = "/verify-identity/proof_of_address";
+var VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH = "/verify-identity/source_of_funds";
+var VERIFY_IDENTITY_ACCREDITATION_PATH = "/verify-identity/accreditation_full";
+var WALLET_PATH = "/wallet";
+
+// src/shared/api/http-attributes.ts
+var empty = {};
+var concat = (left, right) => ({
+  ...left,
+  ...right
+});
+var concatAll = (...items) => {
+  let result = empty;
+  for (const item of items) {
+    result = concat(result, item);
+  }
+  return result;
+};
+var protectedRequest = () => ({ protected: true });
+var userAgent = () => ({ userAgent: true });
+var idempotencyKey = () => ({
+  idempotencyKey: true
+});
+var retryAttempt = (attempt) => ({
+  retryAttempt: attempt
+});
+var renewAttempted = (value) => ({
+  renewAttempted: value
+});
+var isProtected = (attrs) => attrs?.protected === true;
+var needUserAgent = (attrs) => attrs?.userAgent === true;
+var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
+var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
+var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
+var Attributes = {
+  empty,
+  concat,
+  concatAll,
+  protected: protectedRequest,
+  isProtected,
+  userAgent,
+  needUserAgent,
+  idempotencyKey,
+  isIdempotent,
+  retryAttempt,
+  getRetryAttempt,
+  renewAttempted,
+  wasRenewAttempted
+};
+
+// src/shared/api/http.ts
+var HttpError = class extends Error {
+  constructor(response) {
+    super(`Request failed with ${response.status} status`);
+    this.name = "HttpError";
+    this.response = response;
+  }
+};
+async function makeRequest(request) {
+  const headers = {
+    Accept: "application/json",
+    ...request.method === "POST" && request.body !== void 0 ? { "Content-Type": "application/json" } : {},
+    ...request.headers ?? {}
+  };
+  const init = {
+    method: request.method,
+    headers,
+    ...request.redirect !== void 0 ? { redirect: request.redirect } : {}
+  };
+  if (request.method === "POST" && request.body !== void 0) {
+    init.body = JSON.stringify(request.body);
+  }
+  const response = await fetch(
+    buildUrlWithQueryParams(request.url, request.queryParams),
+    init
+  );
+  const responseHeaders = headersToRecord(response.headers);
+  if (response.status === 204 || response.status === 205) {
+    return {
+      status: response.status,
+      body: null,
+      headers: responseHeaders
+    };
+  }
+  if (response.status >= 300 && response.status < 400) {
+    await response.text();
+    return {
+      status: response.status,
+      body: null,
+      headers: responseHeaders
+    };
+  }
+  const text = await response.text();
+  const body = text ? JSON.parse(text) : null;
+  return {
+    status: response.status,
+    body,
+    headers: responseHeaders
+  };
+}
+function buildUrlWithQueryParams(url, queryParams) {
+  if (!queryParams) {
+    return url;
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null) {
+          continue;
+        }
+        searchParams.append(key, String(item));
+      }
+      continue;
+    }
+    searchParams.append(key, String(value));
+  }
+  const queryString = searchParams.toString();
+  if (!queryString) {
+    return url;
+  }
+  return url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key.toLowerCase()] = value;
+  });
+  return record;
+}
+function concatAttributes(request, attrs) {
+  const nextAttributes = Attributes.concat(
+    request.attributes ?? Attributes.empty,
+    attrs
+  );
+  const nextRequest = {
+    ...request,
+    attributes: nextAttributes
+  };
+  return nextRequest;
+}
+var Request = {
+  concatAttributes
+};
+
+// src/shared/api/frontline/offers.ts
+async function fetchAllOffers(api) {
+  return fetchAllPages((params) => fetchOffersPage(api, params));
+}
+async function fetchOffersPage(api, params) {
+  const queryParams = PaginationParams.toQueryParams(params);
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/offers",
+    queryParams,
+    attributes: Attributes.protected()
+  });
+  return PaginatedResponse.fromDto(pageDto, Offer.fromDto);
+}
+async function fetchOfferDetails(api, id) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/offers/${id}`,
+    attributes: Attributes.protected()
+  });
+  return OfferDetail.fromDto(dto);
+}
+
+// src/shared/api/frontline/participations.ts
+async function fetchAllParticipations(api, offerId) {
+  return fetchAllPages(
+    (params) => fetchParticipationsPage(api, params),
+    { offerId }
+  );
+}
+async function fetchParticipationsPage(api, params) {
+  const pageDto = await api.send({
+    method: "GET",
+    url: "/v1/participations",
+    queryParams: ParticipationsPaginationParams.toQueryParams(params),
+    attributes: Attributes.protected()
+  });
+  return PaginatedResponse.fromDto(pageDto, Participation.fromDto);
+}
+async function fetchParticipation(api, id) {
+  const dto = await api.send({
+    method: "GET",
+    url: `/v1/participations/${id}`,
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
+}
+async function createParticipation(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/participations",
+    body: CreateParticipationParams.toDto(params),
+    attributes: Attributes.protected()
+  });
+  return Participation.fromDto(dto);
+}
+
+// src/shared/api/frontline/requirements.ts
+async function fetchOfferRequirements(api, offerId) {
+  const response = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/requirements`,
+    attributes: Attributes.protected()
+  });
+  return Object.fromEntries(
+    Object.entries(response.options).map(([optionId, list]) => [
+      optionId,
+      list.data.map(Requirement.fromDto)
+    ])
+  );
+}
+async function fetchRequirementStatuses(api, offerId) {
+  const response = await api.send({
+    method: "GET",
+    url: `/v1/offers/${offerId}/requirements/statuses`,
+    attributes: Attributes.protected()
+  });
+  return RequirementStatusInfo.fromStatusesDto(response);
+}
+
+// src/shared/api/http-client.ts
+var HttpClient = class {
+  constructor(config, middleware = {}) {
+    this.config = config;
+    this.middleware = middleware;
+  }
+  async send(request) {
+    return this.runRequestWithAfterMiddleware(request);
+  }
+  /**
+   * Runs beforeRequest, executeRequest, then the full afterRequest middleware
+   * chain. Used by send() and by the retry() callback so that when a
+   * middleware calls retry(), the retried response also goes through all
+   * afterRequest middleware (e.g. session renewal, retry). Middleware
+   * must use request.attributes.retryAttempt (or similar) to avoid infinite
+   * recursion when they trigger retries.
+   */
+  async runRequestWithAfterMiddleware(request) {
+    const preparedRequest = await this.runBeforeRequestMiddleware(
+      this.withClientDefaults(request)
+    );
+    let response = await this.executeRequest(preparedRequest);
+    for (const middleware of this.middleware.afterRequest ?? []) {
+      response = await middleware({
+        request: preparedRequest,
+        response,
+        retry: (nextRequest = preparedRequest) => this.runRequestWithAfterMiddleware(nextRequest)
+      });
+    }
+    return response;
+  }
+  withClientDefaults(request) {
+    const url = this.resolveUrl(request.url);
+    const headers = {
+      ...request.headers ?? {},
+      [HEADER_API_VERSION]: this.config.xApiVersion
+    };
+    return {
+      ...request,
+      url,
+      headers
+    };
+  }
+  /**
+   * Resolves a request URL against the client's baseUrl.
+   *
+   * @internal Public only for testing. Do not use in application code; use
+   * {@link HttpClient.send} with a path and the client will resolve the URL.
+   */
+  resolveUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return url;
+    }
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    const path = url.startsWith("/") ? url : `/${url}`;
+    return base + path;
+  }
+  async runBeforeRequestMiddleware(initialRequest) {
+    let request = initialRequest;
+    for (const middleware of this.middleware.beforeRequest ?? []) {
+      request = await middleware(request);
+    }
+    return request;
+  }
+  executeRequest(request) {
+    return makeRequest(request);
+  }
+};
+
+// src/shared/api/middleware/attach-session-middleware.ts
+function attachSessionMiddleware(fetchAccessToken) {
+  return async (request) => {
+    if (!Attributes.isProtected(request.attributes)) {
+      return request;
+    }
+    const accessToken = await fetchAccessToken(false);
+    if (accessToken === null) {
+      return request;
+    }
+    return {
+      ...request,
+      headers: {
+        ...request.headers ?? {},
+        Authorization: `Bearer ${accessToken.value}`
+      }
+    };
+  };
+}
+
+// src/shared/api/middleware/idempotency-key.ts
+var idempotencyKeyMiddleware = async (request) => {
+  if (!Attributes.isIdempotent(request.attributes)) {
+    return request;
+  }
+  const existingHeaders = request.headers ?? {};
+  if (existingHeaders[HEADER_IDEMPOTENCY_KEY]) {
+    return request;
+  }
+  return {
+    ...request,
+    headers: {
+      ...existingHeaders,
+      [HEADER_IDEMPOTENCY_KEY]: getUUIDv4()
+    }
+  };
+};
+
+// src/shared/api/middleware/request-retry.ts
+var MAX_ATTEMPTS = 3;
+var INITIAL_DELAY_MS = 300;
+var MAX_DELAY_MS = 2e3;
+var RETRYABLE_4XX = /* @__PURE__ */ new Set([408, 409, 429]);
+function isRetryableStatus(status) {
+  return status >= 500 && status < 600 || RETRYABLE_4XX.has(status);
+}
+function getRetryDelayMs(attempt) {
+  return Math.min(INITIAL_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS);
+}
+function createRequestRetryMiddleware(options = {}) {
+  const delayFn = options.delayFn ?? defaultDelay;
+  return async ({ request, response, retry }) => {
+    if (!isRetryableStatus(response.status)) {
+      return response;
+    }
+    const currentAttempt = Attributes.getRetryAttempt(request.attributes);
+    if (currentAttempt >= MAX_ATTEMPTS - 1) {
+      return response;
+    }
+    const nextAttempt = currentAttempt + 1;
+    await delayFn(getRetryDelayMs(nextAttempt));
+    const nextRequest = Request.concatAttributes(
+      request,
+      Attributes.retryAttempt(nextAttempt)
+    );
+    return retry(nextRequest);
+  };
+}
+function defaultDelay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var requestRetryMiddleware = createRequestRetryMiddleware();
+
+// src/shared/api/middleware/session-renewal.ts
+function renewSessionMiddleware(fetchAccessToken) {
+  return async ({ request, response, retry }) => {
+    if (response.status !== 401) {
+      return response;
+    }
+    if (!Attributes.isProtected(request.attributes)) {
+      return response;
+    }
+    if (Attributes.wasRenewAttempted(request.attributes)) {
+      return response;
+    }
+    const newToken = await fetchAccessToken(true);
+    if (newToken) {
+      const nextRequest = Request.concatAttributes(
+        request,
+        Attributes.renewAttempted(true)
+      );
+      return retry(nextRequest);
+    } else {
+      return response;
+    }
+  };
+}
+
+// src/shared/api/authenticated-api-client.ts
+var AuthenticatedApiClient = class {
+  constructor(config, fetchAccessToken, additionalBeforeRequest = []) {
+    this.httpClient = new HttpClient(config, {
+      beforeRequest: [
+        attachSessionMiddleware(fetchAccessToken),
+        ...additionalBeforeRequest,
+        idempotencyKeyMiddleware
+      ],
+      afterRequest: [
+        renewSessionMiddleware(fetchAccessToken),
+        requestRetryMiddleware
+      ]
+    });
+  }
+  async send(request) {
+    const response = await this.httpClient.send(request);
+    if (response.status >= 200 && response.status < 300) {
+      return response.body;
+    } else {
+      throw new HttpError(response);
+    }
+  }
+};
+
+export {
+  sha256,
+  arrayBufferToBase64Url,
+  generateSecureRandomBase64Url,
+  getUUIDv4,
+  PUBLIC_API_BASE_URL,
+  HEADER_USER_AGENT,
+  API_VERSION,
+  COINLIST_BASE_URL,
+  OAUTH_PAGE_PATH,
+  SUPPORT_NEW_TICKET_URL,
+  VERIFY_IDENTITY_PATH,
+  VERIFY_IDENTITY_VERIFIED_PATH,
+  VERIFY_IDENTITY_PROOF_OF_ADDRESS_PATH,
+  VERIFY_IDENTITY_SOURCE_OF_FUNDS_PATH,
+  VERIFY_IDENTITY_ACCREDITATION_PATH,
+  WALLET_PATH,
+  Attributes,
+  HttpError,
+  AuthenticatedApiClient,
+  Cursor,
+  fetchAllPages,
+  PaginatedResponse,
+  PaginationParams,
+  OfferId,
+  OfferSlug,
+  Offer,
+  OfferOptionId,
+  OfferOptionSlug,
+  OfferDetail,
+  OfferOption,
+  FaqItem,
+  Link,
+  TermItem,
+  Milestone,
+  fetchAllOffers,
+  fetchOffersPage,
+  fetchOfferDetails,
+  ParticipationId,
+  Blockchain,
+  WalletAddress,
+  ParticipationsPaginationParams,
+  Participation,
+  CreateParticipationParams,
+  fetchAllParticipations,
+  fetchParticipationsPage,
+  fetchParticipation,
+  createParticipation,
+  RequirementId,
+  Requirement,
+  RequirementStatusInfo,
+  fetchOfferRequirements,
+  fetchRequirementStatuses,
+  NotImplementedError,
+  NotAuthenticatedError,
+  AuthorizationCode,
+  CodeVerifier,
+  CodeChallenge,
+  RedirectUri,
+  ClientId,
+  ClientSecret
+};
+//# sourceMappingURL=chunk-NC45IO63.js.map