@satrush/api 0.1.0 → 0.1.2

package/README.md

@@ -14,16 +14,14 @@ pnpm add @satrush/api
 ## Usage
 
 ```ts
-import {SatrushBackendSdk, createClient, unwrap} from "@satrush/api";
+import { SatrushBackendSdk, createClient, unwrap } from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
+  baseUrl: 'https://api.satrush.io/api'
 });
-const sdk = new SatrushBackendSdk({client});
+const sdk = new SatrushBackendSdk({ client });
 
-const board = await unwrap(
-    sdk.getBoard(),
-);
+const board = await unwrap(sdk.getBoard());
 ```
 
 ## How the SDK works
@@ -32,10 +30,10 @@ const board = await unwrap(
 - Pre-processing: `scripts/camelizeOpenapi.mjs` produces `openapi.camel.yaml` (converts snake_case into cameCase).
 - Code generation: `@hey-api/openapi-ts` generates `src/generated/**`.
 - Post-processing: `scripts/postprocessOpenapi.mjs` patches the generated client to:
-    - snake_case request payloads/params
-    - camelCase response payloads
-    - apply response transforms before validators where needed
-    - apply custom SSE transforms (see below)
+  - snake_case request payloads/params
+  - camelCase response payloads
+  - apply response transforms before validators where needed
+  - apply custom SSE transforms (see below)
 
 ## Case transforms and scalar transforms
 
@@ -59,15 +57,19 @@ To throw on non-2xx responses for all SDK calls, set `throwOnError: true` on the
 and attach the built-in interceptor that wraps errors as `SatRushSdkError`:
 
 ```ts
-import {SatRushBackendSdk, createClient, satrushSdkErrorInterceptor} from "@satrush/api";
+import {
+  SatRushBackendSdk,
+  createClient,
+  satrushSdkErrorInterceptor
+} from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
-    throwOnError: true,
+  baseUrl: 'https://api.satrush.io/api',
+  throwOnError: true
 });
 client.interceptors.error.use(satrushSdkErrorInterceptor);
 
-const sdk = new SatRushBackendSdk({client});
+const sdk = new SatRushBackendSdk({ client });
 ```
 
 `SatRushSdkError` includes the HTTP status and the original error payload in `cause`.
@@ -75,9 +77,9 @@ const sdk = new SatRushBackendSdk({client});
 If you already have a client, you can also enable it later:
 
 ```ts
-import {client, satrushSdkErrorInterceptor} from "@satrush/api";
+import { client, satrushSdkErrorInterceptor } from '@satrush/api';
 
-client.setConfig({throwOnError: true});
+client.setConfig({ throwOnError: true });
 client.interceptors.error.use(satrushSdkErrorInterceptor);
 ```
 
@@ -85,13 +87,13 @@ When `responseStyle` is set to `"data"`, SDK calls return only the response payl
 (no `{ data, error, request, response }` wrapper). This is useful for simpler call sites:
 
 ```ts
-import {SatRushBackendSdk, createClient} from "@satrush/api";
+import { SatRushBackendSdk, createClient } from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
-    responseStyle: "data",
+  baseUrl: 'https://api.satrush.io/api',
+  responseStyle: 'data'
 });
 
-const sdk = new SatrushBackendSdk({client});
+const sdk = new SatrushBackendSdk({ client });
 const board = await sdk.getBoard();
 ```

package/dist/index.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  NotificationEntity: () => NotificationEntity,
   RoundStateDto: () => RoundStateDto,
   SatrushBackendSdk: () => SatrushBackendSdk,
   SatrushBackendSdkError: () => SatrushBackendSdkError,
@@ -37,19 +38,39 @@ __export(index_exports, {
   isSatrushSdkError: () => isSatrushSdkError,
   satrushSdkErrorInterceptor: () => satrushSdkErrorInterceptor,
   unwrap: () => unwrap,
+  zBadRequestErrorCodeErrorBody: () => zBadRequestErrorCodeErrorBody,
   zBoardDto: () => zBoardDto,
+  zFieldError: () => zFieldError,
   zGetBoardData: () => zGetBoardData,
   zGetBoardResponse: () => zGetBoardResponse,
+  zGetConfigData: () => zGetConfigData,
+  zGetConfigResponse: () => zGetConfigResponse,
+  zGetUserProfileData: () => zGetUserProfileData,
+  zGetUserProfileResponse: () => zGetUserProfileResponse,
   zI128Dto: () => zI128Dto,
   zI64Dto: () => zI64Dto,
   zInternalErrorCodeErrorBody: () => zInternalErrorCodeErrorBody,
+  zMinerDto: () => zMinerDto,
+  zNotificationEntity: () => zNotificationEntity,
+  zProfileDto: () => zProfileDto,
   zPubkeyDto: () => zPubkeyDto,
+  zPublicDeploymentDto: () => zPublicDeploymentDto,
   zRoundDto: () => zRoundDto,
   zRoundStateDto: () => zRoundStateDto,
+  zSatrushConfigDto: () => zSatrushConfigDto,
+  zSnapshotDto: () => zSnapshotDto,
+  zSseData: () => zSseData,
+  zSseResponse: () => zSseResponse,
+  zSseResponse2: () => zSseResponse2,
+  zSseResponseSnapshot: () => zSseResponseSnapshot,
   zStrikeJackpotDto: () => zStrikeJackpotDto,
   zTileStakeDto: () => zTileStakeDto,
   zU128Dto: () => zU128Dto,
-  zU64Dto: () => zU64Dto
+  zU64Dto: () => zU64Dto,
+  zUserProfileApiError400Error: () => zUserProfileApiError400Error,
+  zUserProfileApiError400InvalidAddress: () => zUserProfileApiError400InvalidAddress,
+  zValidationErrorCodeErrorBody: () => zValidationErrorCodeErrorBody,
+  zValidationErrorCodeValidationDetailsErrorBody: () => zValidationErrorCodeValidationDetailsErrorBody
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -73,6 +94,140 @@ var extraPrefixesMap = {
   $query_: "query"
 };
 var extraPrefixes = Object.entries(extraPrefixesMap);
+var buildKeyMap = (fields, map) => {
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+  }
+  for (const config of fields) {
+    if ("in" in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map
+        });
+      }
+    } else if ("key" in config) {
+      map.set(config.key, {
+        map: config.map
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+  return map;
+};
+var stripEmptySlots = (params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === "object" && !Object.keys(value).length) {
+      delete params[slot];
+    }
+  }
+};
+var buildClientParams = (args, fields) => {
+  const params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {}
+  };
+  const map = buildKeyMap(fields);
+  let config;
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+    if (!config) {
+      continue;
+    }
+    if ("in" in config) {
+      if (config.key) {
+        const field = map.get(config.key);
+        const name = field.map || config.key;
+        if (field.in) {
+          params[field.in][name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            params[field.in][name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+          if (extra) {
+            const [prefix, slot] = extra;
+            params[slot][key.slice(prefix.length)] = value;
+          } else if ("allowExtra" in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                params[slot][key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  stripEmptySlots(params);
+  return params;
+};
+
+// src/utils/sse.ts
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var applySseResponseTransforms = async (payload) => {
+  if (!isRecord(payload)) return payload;
+  return payload;
+};
+
+// src/utils/transforms.ts
+var snakeToCamel = (value) => value.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+var camelToSnake = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+var isPlainObject = (value) => !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+var mapKeysDeep = (value, mapKey) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapKeysDeep(item, mapKey));
+  }
+  if (isPlainObject(value)) {
+    const next = {};
+    for (const [key, val] of Object.entries(value)) {
+      next[mapKey(key)] = mapKeysDeep(val, mapKey);
+    }
+    return next;
+  }
+  return value;
+};
+var shouldTransformBody = (value) => isPlainObject(value) || Array.isArray(value);
+var snakecaseQuerySerializerParams = (value) => {
+  if (!isPlainObject(value)) return value;
+  if (!isPlainObject(value.parameters)) return value;
+  const nextParameters = {};
+  for (const [key, param] of Object.entries(value.parameters)) {
+    nextParameters[camelToSnake(key)] = param;
+  }
+  return { ...value, parameters: nextParameters };
+};
+var applyRequestCaseTransforms = (options) => {
+  const next = { ...options };
+  if ("query" in next && isPlainObject(next.query)) {
+    next.query = mapKeysDeep(next.query, camelToSnake);
+  }
+  if ("querySerializer" in next && next.querySerializer) {
+    next.querySerializer = snakecaseQuerySerializerParams(next.querySerializer);
+  }
+  if ("body" in next && shouldTransformBody(next.body)) {
+    next.body = mapKeysDeep(next.body, camelToSnake);
+  }
+  return next;
+};
+var applyResponseCaseTransforms = (value) => mapKeysDeep(value, snakeToCamel);
 
 // src/generated/core/serverSentEvents.gen.ts
 var createSseClient = ({
@@ -164,9 +319,11 @@ var createSseClient = ({
                 }
               }
               if (parsedJson) {
+                data = applyResponseCaseTransforms(data);
                 if (responseValidator) {
                   await responseValidator(data);
                 }
+                data = await applySseResponseTransforms(data);
                 if (responseTransformer) {
                   data = await responseTransformer(data);
                 }
@@ -422,48 +579,6 @@ function getValidRequestBody(options) {
   return void 0;
 }
 
-// src/utils/transforms.ts
-var snakeToCamel = (value) => value.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-var camelToSnake = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
-var isPlainObject = (value) => !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
-var mapKeysDeep = (value, mapKey) => {
-  if (Array.isArray(value)) {
-    return value.map((item) => mapKeysDeep(item, mapKey));
-  }
-  if (isPlainObject(value)) {
-    const next = {};
-    for (const [key, val] of Object.entries(value)) {
-      next[mapKey(key)] = mapKeysDeep(val, mapKey);
-    }
-    return next;
-  }
-  return value;
-};
-var shouldTransformBody = (value) => isPlainObject(value) || Array.isArray(value);
-var snakecaseQuerySerializerParams = (value) => {
-  if (!isPlainObject(value)) return value;
-  if (!isPlainObject(value.parameters)) return value;
-  const nextParameters = {};
-  for (const [key, param] of Object.entries(value.parameters)) {
-    nextParameters[camelToSnake(key)] = param;
-  }
-  return { ...value, parameters: nextParameters };
-};
-var applyRequestCaseTransforms = (options) => {
-  const next = { ...options };
-  if ("query" in next && isPlainObject(next.query)) {
-    next.query = mapKeysDeep(next.query, camelToSnake);
-  }
-  if ("querySerializer" in next && next.querySerializer) {
-    next.querySerializer = snakecaseQuerySerializerParams(next.querySerializer);
-  }
-  if ("body" in next && shouldTransformBody(next.body)) {
-    next.body = mapKeysDeep(next.body, camelToSnake);
-  }
-  return next;
-};
-var applyResponseCaseTransforms = (value) => mapKeysDeep(value, snakeToCamel);
-
 // src/generated/core/auth.gen.ts
 var getAuthToken = async (auth, callback) => {
   const token = typeof callback === "function" ? await callback(auth) : callback;
@@ -950,14 +1065,64 @@ var getBoardResponseTransformer = async (data) => {
   data.data = boardDtoSchemaResponseTransformer(data.data);
   return data;
 };
+var publicDeploymentDtoSchemaResponseTransformer = (data) => {
+  data.deployedUsdAmount = u64DtoSchemaResponseTransformer(data.deployedUsdAmount);
+  return data;
+};
+var minerDtoSchemaResponseTransformer = (data) => {
+  data.hashrateAmount = u64DtoSchemaResponseTransformer(data.hashrateAmount);
+  data.unclaimedBtcShares = u64DtoSchemaResponseTransformer(data.unclaimedBtcShares);
+  data.unclaimedUsdAmount = u64DtoSchemaResponseTransformer(data.unclaimedUsdAmount);
+  return data;
+};
+var profileDtoSchemaResponseTransformer = (data) => {
+  data.deployments = data.deployments.map((item) => publicDeploymentDtoSchemaResponseTransformer(item));
+  data.miner = minerDtoSchemaResponseTransformer(data.miner);
+  return data;
+};
+var snapshotDtoSchemaResponseTransformer = (data) => {
+  data.board = boardDtoSchemaResponseTransformer(data.board);
+  if (data.profile) {
+    data.profile = profileDtoSchemaResponseTransformer(data.profile);
+  }
+  return data;
+};
+var sseResponseSnapshotSchemaResponseTransformer = (data) => {
+  data = snapshotDtoSchemaResponseTransformer(data);
+  return data;
+};
+var sseResponseSchemaResponseTransformer = (data) => {
+  data = sseResponseSnapshotSchemaResponseTransformer(data);
+  return data;
+};
+var sseResponseTransformer = async (data) => {
+  data = sseResponseSchemaResponseTransformer(data);
+  return data;
+};
+var getUserProfileResponseTransformer = async (data) => {
+  data.data = profileDtoSchemaResponseTransformer(data.data);
+  return data;
+};
 
 // src/generated/zod.gen.ts
 var z = __toESM(require("zod"), 1);
+var zBadRequestErrorCodeErrorBody = z.object({
+  code: z.enum([
+    "invalid_path",
+    "invalid_query",
+    "invalid_body"
+  ])
+});
+var zFieldError = z.object({
+  field: z.string(),
+  message: z.string()
+});
 var zI128Dto = z.string();
 var zI64Dto = z.coerce.bigint().min(BigInt("-9223372036854775808"), { error: "Invalid value: Expected int64 to be >= -9223372036854775808" }).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" });
 var zInternalErrorCodeErrorBody = z.object({
   code: z.enum(["internal_error"])
 });
+var zNotificationEntity = z.enum(["state_snapshot"]);
 var zPubkeyDto = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
 var zRoundStateDto = z.enum([
   "active",
@@ -965,8 +1130,37 @@ var zRoundStateDto = z.enum([
   "settled",
   "finished"
 ]);
+var zSatrushConfigDto = z.object({
+  address: zPubkeyDto,
+  btcMint: zPubkeyDto,
+  epochFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  oneBtcFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  protocolFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  satsVaultClaimFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  satsVaultRoundFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  strikeFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  usdMint: zPubkeyDto
+});
 var zU128Dto = z.string();
 var zU64Dto = z.coerce.bigint().min(BigInt("0"), { error: "Invalid value: Expected uint64 to be >= 0" }).max(BigInt("18446744073709551615"), { error: "Invalid value: Expected uint64 to be <= 18446744073709551615" });
+var zMinerDto = z.object({
+  authority: zPubkeyDto,
+  currentStreakCount: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  hashrateAmount: zU64Dto,
+  lastMinedRoundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  unclaimedBtcShares: zU64Dto,
+  unclaimedUsdAmount: zU64Dto
+});
+var zPublicDeploymentDto = z.object({
+  address: zPubkeyDto,
+  deployedUsdAmount: zU64Dto,
+  roundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  selectionMask: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+var zProfileDto = z.object({
+  deployments: z.array(zPublicDeploymentDto),
+  miner: zMinerDto
+});
 var zStrikeJackpotDto = z.object({
   btcAmount: zU64Dto,
   lastTriggerRoundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -1014,6 +1208,47 @@ var zBoardDto = z.object({
   startSlot: zU64Dto,
   strike: zStrikeJackpotDto
 });
+var zSnapshotDto = z.object({
+  board: zBoardDto,
+  entity: zNotificationEntity,
+  profile: z.optional(z.union([
+    z.null(),
+    zProfileDto
+  ]))
+});
+var zSseResponseSnapshot = zSnapshotDto.and(z.object({
+  entity: z.enum(["state_snapshot"])
+}));
+var zSseResponse = z.object({
+  entity: z.literal("state_snapshot")
+}).and(zSseResponseSnapshot);
+var zUserProfileApiError400InvalidAddress = z.object({
+  code: z.enum(["invalid_address"])
+});
+var zUserProfileApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_address")
+  }).and(zUserProfileApiError400InvalidAddress),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zValidationErrorCodeErrorBody = z.object({
+  code: z.enum(["validation_failed"]),
+  data: z.optional(z.object({
+    errors: z.array(zFieldError)
+  }))
+});
+var zValidationErrorCodeValidationDetailsErrorBody = z.object({
+  code: z.enum(["validation_failed"]),
+  data: z.optional(z.object({
+    errors: z.array(zFieldError)
+  }))
+});
 var zGetBoardData = z.object({
   body: z.optional(z.never()),
   path: z.optional(z.never()),
@@ -1022,6 +1257,32 @@ var zGetBoardData = z.object({
 var zGetBoardResponse = z.object({
   data: zBoardDto
 });
+var zGetConfigData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetConfigResponse = z.object({
+  data: zSatrushConfigDto
+});
+var zSseData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    wallet: z.optional(z.string())
+  }))
+});
+var zSseResponse2 = zSseResponse;
+var zGetUserProfileData = z.object({
+  body: z.optional(z.never()),
+  path: z.object({
+    address: z.string()
+  }),
+  query: z.optional(z.never())
+});
+var zGetUserProfileResponse = z.object({
+  data: zProfileDto
+});
 
 // src/generated/sdk.gen.ts
 var HeyApiClient = class {
@@ -1062,9 +1323,49 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
       ...options
     });
   }
+  /**
+   * Request config
+   */
+  getConfig(options) {
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetConfigData.parseAsync(data),
+      responseValidator: async (data) => await zGetConfigResponse.parseAsync(data),
+      url: "/v1/config",
+      ...options
+    });
+  }
+  /**
+   * Subscribe for SSE stream
+   */
+  sse(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "wallet" }] }]);
+    return (options?.client ?? this.client).sse.get({
+      requestValidator: async (data) => await zSseData.parseAsync(data),
+      responseTransformer: sseResponseTransformer,
+      responseValidator: async (data) => await zSseResponse2.parseAsync(data),
+      url: "/v1/streams/sse",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request user profile
+   */
+  getUserProfile(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "address" }] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetUserProfileData.parseAsync(data),
+      responseTransformer: getUserProfileResponseTransformer,
+      responseValidator: async (data) => await zGetUserProfileResponse.parseAsync(data),
+      url: "/v1/user/{address}/profile",
+      ...options,
+      ...params
+    });
+  }
 };
 
 // src/generated/types.gen.ts
+var NotificationEntity = { STATE_SNAPSHOT: "state_snapshot" };
 var RoundStateDto = {
   ACTIVE: "active",
   REVEALED: "revealed",
@@ -1104,7 +1405,11 @@ async function unwrap(promise) {
   if (res && typeof res === "object" && "response" in res) {
     const sdkRes = res;
     if ("error" in sdkRes && sdkRes.error !== void 0) {
-      throw new SatrushBackendSdkError(String(sdkRes.error), sdkRes.response?.status ?? 0, sdkRes.error);
+      throw new SatrushBackendSdkError(
+        String(sdkRes.error),
+        sdkRes.response?.status ?? 0,
+        sdkRes.error
+      );
     }
     if ("data" in sdkRes) {
       return unwrapData(sdkRes.data);
@@ -1114,6 +1419,7 @@ async function unwrap(promise) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NotificationEntity,
   RoundStateDto,
   SatrushBackendSdk,
   SatrushBackendSdkError,
@@ -1122,17 +1428,37 @@ async function unwrap(promise) {
   isSatrushSdkError,
   satrushSdkErrorInterceptor,
   unwrap,
+  zBadRequestErrorCodeErrorBody,
   zBoardDto,
+  zFieldError,
   zGetBoardData,
   zGetBoardResponse,
+  zGetConfigData,
+  zGetConfigResponse,
+  zGetUserProfileData,
+  zGetUserProfileResponse,
   zI128Dto,
   zI64Dto,
   zInternalErrorCodeErrorBody,
+  zMinerDto,
+  zNotificationEntity,
+  zProfileDto,
   zPubkeyDto,
+  zPublicDeploymentDto,
   zRoundDto,
   zRoundStateDto,
+  zSatrushConfigDto,
+  zSnapshotDto,
+  zSseData,
+  zSseResponse,
+  zSseResponse2,
+  zSseResponseSnapshot,
   zStrikeJackpotDto,
   zTileStakeDto,
   zU128Dto,
-  zU64Dto
+  zU64Dto,
+  zUserProfileApiError400Error,
+  zUserProfileApiError400InvalidAddress,
+  zValidationErrorCodeErrorBody,
+  zValidationErrorCodeValidationDetailsErrorBody
 });