nolo-cli 0.1.31 → 0.1.32

package/integrations/resend/index.ts

@@ -1,353 +0,0 @@
-export interface ResendEmailOptions {
-  from?: string;
-  to: string;
-  subject: string;
-  textBody?: string;
-  htmlBody?: string;
-  tag?: string;
-}
-
-export interface ResendBatchEmailOptions {
-  from?: string;
-  to: string | string[];
-  subject: string;
-  textBody?: string;
-  htmlBody?: string;
-  tag?: string;
-}
-
-export interface ResendMarketingRecipient {
-  email: string;
-  firstName?: string;
-  lastName?: string;
-  unsubscribed?: boolean;
-}
-
-export interface ResendMarketingBroadcastOptions {
-  from?: string;
-  segmentId: string;
-  recipients: ResendMarketingRecipient[];
-  previousRecipientEmails?: string[];
-  subject: string;
-  textBody?: string;
-  htmlBody?: string;
-  tag?: string;
-}
-
-const RESEND_API_URL = "https://api.resend.com/emails";
-const RESEND_BATCH_API_URL = "https://api.resend.com/emails/batch";
-const RESEND_CONTACTS_API_URL = "https://api.resend.com/contacts";
-const RESEND_BROADCAST_API_URL = "https://api.resend.com/broadcasts";
-const DEFAULT_TIMEOUT_MS = 10_000;
-const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
-const DEFAULT_RETRY_BASE_DELAY_MS = 500;
-const MAX_BATCH_SIZE = 100;
-const MAX_RECIPIENTS_PER_EMAIL = 50;
-const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-
-const parseNumber = (value: string | undefined, fallback: number, min = 1) => {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(min, Math.floor(parsed));
-};
-
-const sleep = (ms: number) =>
-  ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
-
-const normalizeTag = (tag?: string) => {
-  const value = tag?.trim();
-  if (!value) return undefined;
-  return [{ name: "campaign", value }];
-};
-
-const normalizeRecipients = (to: string | string[]) => {
-  const recipients = (Array.isArray(to) ? to : [to]).map((item) => String(item || "").trim());
-  if (recipients.length === 0) {
-    throw new Error("At least one recipient email address is required");
-  }
-  if (recipients.length > MAX_RECIPIENTS_PER_EMAIL) {
-    throw new Error(`Each email supports up to ${MAX_RECIPIENTS_PER_EMAIL} recipients`);
-  }
-  for (const recipient of recipients) {
-    if (!EMAIL_PATTERN.test(recipient)) {
-      throw new Error("Invalid recipient email address");
-    }
-  }
-  return recipients;
-};
-
-const getRetryAfterMs = (retryAfter: string | null) => {
-  if (!retryAfter) return null;
-  const seconds = Number(retryAfter);
-  if (Number.isFinite(seconds)) {
-    return Math.max(0, Math.floor(seconds * 1000));
-  }
-  const timestamp = Date.parse(retryAfter);
-  if (!Number.isNaN(timestamp)) {
-    return Math.max(0, timestamp - Date.now());
-  }
-  return null;
-};
-
-const isRetryableStatus = (status: number) => status === 429 || status >= 500;
-
-const parseResponsePayload = async (response: Response) => {
-  const payloadText = await response.text();
-  if (!payloadText) return {};
-  try {
-    return JSON.parse(payloadText);
-  } catch {
-    return { message: payloadText };
-  }
-};
-
-const getResendErrorMessage = (result: any) =>
-  result?.error?.message || result?.message || "Unknown Resend error";
-
-const createTimeoutSignal = (timeoutMs: number) =>
-  typeof AbortSignal !== "undefined" &&
-  typeof (AbortSignal as any).timeout === "function"
-    ? (AbortSignal as any).timeout(timeoutMs)
-    : undefined;
-
-const normalizeEmailAddress = (value: string) => {
-  const normalized = String(value || "").trim().toLowerCase();
-  if (!EMAIL_PATTERN.test(normalized)) {
-    throw new Error("Invalid recipient email address");
-  }
-  return normalized;
-};
-
-const isResendErrorStatus = (error: unknown, status: number) =>
-  error instanceof Error && error.message.includes(`Resend error (${status})`);
-
-const isResendConflictError = (error: unknown) =>
-  isResendErrorStatus(error, 409) ||
-  (error instanceof Error && /already exists/i.test(error.message));
-
-const requestResend = async (
-  url: string,
-  body: unknown,
-  method: "POST" | "PATCH" | "DELETE" = "POST"
-) => {
-  const apiKey = process.env.RESEND_API_KEY;
-  if (!apiKey) {
-    throw new Error("RESEND_API_KEY is not defined");
-  }
-
-  const timeoutMs = parseNumber(
-    process.env.RESEND_TIMEOUT_MS,
-    DEFAULT_TIMEOUT_MS,
-    1_000
-  );
-  const maxRetryAttempts = parseNumber(
-    process.env.RESEND_MAX_RETRY_ATTEMPTS,
-    DEFAULT_MAX_RETRY_ATTEMPTS,
-    1
-  );
-  const retryBaseDelayMs = parseNumber(
-    process.env.RESEND_RETRY_BASE_DELAY_MS,
-    DEFAULT_RETRY_BASE_DELAY_MS,
-    100
-  );
-
-  let lastError: unknown = null;
-  for (let attempt = 1; attempt <= maxRetryAttempts; attempt += 1) {
-    try {
-      const payload =
-        body === undefined || method === "DELETE" ? undefined : JSON.stringify(body);
-      const response = await fetch(url, {
-        method,
-        signal: createTimeoutSignal(timeoutMs),
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json",
-        },
-        body: payload,
-      });
-
-      const result = await parseResponsePayload(response);
-      if (response.ok) {
-        return result;
-      }
-
-      const errorMessage = getResendErrorMessage(result);
-      const canRetry = isRetryableStatus(response.status) && attempt < maxRetryAttempts;
-      if (canRetry) {
-        const retryAfterMs = getRetryAfterMs(response.headers.get("retry-after"));
-        const backoffMs =
-          retryAfterMs ?? retryBaseDelayMs * Math.pow(2, attempt - 1);
-        await sleep(backoffMs);
-        continue;
-      }
-
-      throw new Error(`Resend error (${response.status}): ${errorMessage}`);
-    } catch (error: any) {
-      lastError = error;
-      const isTransientNetworkError =
-        error?.name === "AbortError" || error instanceof TypeError;
-      if (isTransientNetworkError && attempt < maxRetryAttempts) {
-        const backoffMs = retryBaseDelayMs * Math.pow(2, attempt - 1);
-        await sleep(backoffMs);
-        continue;
-      }
-      throw error;
-    }
-  }
-
-  if (lastError instanceof Error) throw lastError;
-  throw new Error("Resend request failed after retries");
-};
-
-export async function sendEmail({
-  from,
-  to,
-  subject,
-  textBody,
-  htmlBody,
-  tag,
-}: ResendEmailOptions) {
-  const defaultFrom = process.env.RESEND_FROM_EMAIL;
-  const recipients = normalizeRecipients(to);
-
-  const sender = from || defaultFrom;
-  if (!sender) {
-    throw new Error("RESEND_FROM_EMAIL is not defined");
-  }
-
-  if (!textBody && !htmlBody) {
-    throw new Error("Either textBody or htmlBody is required");
-  }
-
-  return requestResend(RESEND_API_URL, {
-    from: sender,
-    to: recipients,
-    subject,
-    text: textBody,
-    html: htmlBody,
-    tags: normalizeTag(tag),
-  });
-}
-
-export async function sendBatchEmails(emails: ResendBatchEmailOptions[]) {
-  if (!Array.isArray(emails) || emails.length === 0) {
-    throw new Error("Batch emails payload is empty");
-  }
-  if (emails.length > MAX_BATCH_SIZE) {
-    throw new Error(`Batch send supports up to ${MAX_BATCH_SIZE} emails per request`);
-  }
-
-  const defaultFrom = process.env.RESEND_FROM_EMAIL;
-  const batchPayload = emails.map((email) => {
-    const sender = email.from || defaultFrom;
-    if (!sender) {
-      throw new Error("RESEND_FROM_EMAIL is not defined");
-    }
-    if (!email.textBody && !email.htmlBody) {
-      throw new Error("Either textBody or htmlBody is required");
-    }
-
-    return {
-      from: sender,
-      to: normalizeRecipients(email.to),
-      subject: email.subject,
-      text: email.textBody,
-      html: email.htmlBody,
-      tags: normalizeTag(email.tag),
-    };
-  });
-
-  return requestResend(RESEND_BATCH_API_URL, batchPayload);
-}
-
-export async function sendMarketingBroadcast({
-  from,
-  segmentId,
-  recipients,
-  previousRecipientEmails,
-  subject,
-  textBody,
-  htmlBody,
-  tag,
-}: ResendMarketingBroadcastOptions) {
-  const defaultFrom = process.env.RESEND_FROM_EMAIL;
-  const sender = from || defaultFrom;
-  if (!sender) {
-    throw new Error("RESEND_FROM_EMAIL is not defined");
-  }
-
-  const normalizedSegmentId = String(segmentId || "").trim();
-  if (!normalizedSegmentId) {
-    throw new Error("segmentId is required for marketing broadcast");
-  }
-  if (!Array.isArray(recipients) || recipients.length === 0) {
-    throw new Error("Marketing broadcast recipients payload is empty");
-  }
-  if (!textBody && !htmlBody) {
-    throw new Error("Either textBody or htmlBody is required");
-  }
-
-  const uniqueRecipients = new Map<string, ResendMarketingRecipient>();
-  for (const recipient of recipients) {
-    const email = normalizeEmailAddress(recipient.email);
-    if (!uniqueRecipients.has(email)) {
-      uniqueRecipients.set(email, { ...recipient, email });
-    }
-  }
-
-  const encodedSegmentId = encodeURIComponent(normalizedSegmentId);
-  const currentEmails = new Set(uniqueRecipients.keys());
-  for (const recipient of uniqueRecipients.values()) {
-    const contactPayload = {
-      email: recipient.email,
-      first_name: recipient.firstName?.trim() || undefined,
-      last_name: recipient.lastName?.trim() || undefined,
-      unsubscribed: Boolean(recipient.unsubscribed),
-      segments: [{ id: normalizedSegmentId }],
-    };
-    try {
-      await requestResend(RESEND_CONTACTS_API_URL, contactPayload);
-    } catch (error) {
-      if (!isResendConflictError(error)) {
-        throw error;
-      }
-      await requestResend(
-        `${RESEND_CONTACTS_API_URL}/${encodeURIComponent(recipient.email)}/segments/${encodedSegmentId}`,
-        undefined
-      );
-    }
-  }
-
-  const staleRecipients = Array.from(
-    new Set(
-      (previousRecipientEmails || [])
-        .map((value) => String(value || "").trim().toLowerCase())
-        .filter(Boolean)
-    )
-  ).filter((email) => !currentEmails.has(email));
-
-  for (const email of staleRecipients) {
-    try {
-      await requestResend(
-        `${RESEND_CONTACTS_API_URL}/${encodeURIComponent(email)}/segments/${encodedSegmentId}`,
-        undefined,
-        "DELETE"
-      );
-    } catch (error) {
-      if (isResendErrorStatus(error, 404)) {
-        continue;
-      }
-      throw error;
-    }
-  }
-
-  return requestResend(RESEND_BROADCAST_API_URL, {
-    name: tag ? `auto-${String(tag).trim().toLowerCase()}-${Date.now()}` : undefined,
-    segment_id: normalizedSegmentId,
-    from: sender,
-    subject,
-    text: textBody,
-    html: htmlBody,
-    send: true,
-  });
-}

package/integrations/weather/getWeather.ts

@@ -1,24 +0,0 @@
-import { API_ENDPOINTS } from "../../database/config";
-
-import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
-export async function getWeather(
-  params: WeatherQueryParams,
-): Promise<WeatherApiResponse> {
-  const searchParams = new URLSearchParams({
-    lat: params.lat.toString(),
-    lng: params.lng.toString(),
-    params: params.params.join(","),
-    ...(params.start && { start: params.start }),
-    ...(params.end && { end: params.end }),
-    ...(params.source && { source: params.source }),
-  }).toString();
-
-  const response = await fetch(`${API_ENDPOINTS.WEATHER}?${searchParams}`);
-
-  if (!response.ok) {
-    // 如果响应状态不是2xx，抛出错误
-    throw new Error("Network response was not ok");
-  }
-
-  return response.json();
-}

package/integrations/weather/index.ts

@@ -1,6 +0,0 @@
-export * from "./weatherTypes";
-export * from "./weatherConstants";
-export * from "./weatherUtils";
-export * from "./routes";
-export * from "./weatherApi";
-export * from "./weatherService";

package/integrations/weather/routes.ts

@@ -1,31 +0,0 @@
-import { fetchWeatherData } from "./weatherService";
-
-export async function weatherRouteHandler(req, res) {
-  try {
-    // 将字符串参数转换为浮点数
-    const lat = parseFloat(req.query.lat);
-    const lng = parseFloat(req.query.lng);
-
-    // 检查是否提供了params查询参数并进行处理，此处假设params是逗号分隔的字符串
-    const params = req.query.params ? req.query.params.split(",") : [];
-    const start = req.query.start;
-    const end = req.query.end;
-    // 确保lat和lng是数字类型且params是一个字符串数组
-    if (!isNaN(lat) && !isNaN(lng) && Array.isArray(params)) {
-      const queryParams = {
-        lat,
-        lng,
-        params, // 传入处理过的params数组
-        start,
-        end,
-      };
-      const data = await fetchWeatherData(queryParams);
-
-      return res.json(data);
-    }
-    return res.status(400).json({ message: "Invalid query parameters" });
-  } catch (error) {
-    // 如果API调用失败，返回500错误及错误信息
-    return res.status(500).json({ message: error.message });
-  }
-}

package/integrations/weather/weatherApi.ts

@@ -1,27 +0,0 @@
-import { API_ENDPOINTS } from "../../database/config";
-
-import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
-//maybe need delete
-// export const weatherApi = api.injectEndpoints({
-//   endpoints: (builder) => ({
-//     getWeather: builder.query<WeatherApiResponse, WeatherQueryParams>({
-//       query: (params) => {
-//         const searchParams = {
-//           lat: params.lat.toString(),
-//           lng: params.lng.toString(),
-//           params: params.params.join(","),
-//           // 其他可能的查询参数, 如果它们存在
-//           ...(params.start && { start: params.start }),
-//           ...(params.end && { end: params.end }),
-//           ...(params.source && { source: params.source }),
-//         };
-//         return {
-//           url: `${API_ENDPOINTS.WEATHER}`,
-//           params: searchParams,
-//         };
-//       },
-//     }),
-//   }),
-// });
-
-export const useGetWeatherQuery = () => {};

package/integrations/weather/weatherConstants.ts

@@ -1,2 +0,0 @@
-export const WEATHER_API_ENDPOINT = '/weather';
-// ... 可能的其他常量定义

package/integrations/weather/weatherI18n.ts

@@ -1,50 +0,0 @@
-export default {
-  en: {
-    translation: {
-      time: "Time",
-      swellDirection: "Swell Dir",
-      windDirection: "Wind Dir",
-      windSpeed: "Wind Spd",
-      swellHeight: "Swell Hgt",
-      swellPeriod: "Swell Prd",
-      gust: "Gust",
-      airTemperature: "Air Temp",
-    },
-  },
-  "zh-CN": {
-    translation: {
-      time: "时间",
-      swellDirection: "浪向",
-      windDirection: "风向",
-      windSpeed: "风速",
-      swellHeight: "浪高",
-      swellPeriod: "周期",
-      gust: "阵风",
-      airTemperature: "气温",
-    },
-  },
-  "zh-Hant": {
-    translation: {
-      time: "時間",
-      swellDirection: "浪向",
-      windDirection: "風向",
-      windSpeed: "風速",
-      swellHeight: "浪高",
-      swellPeriod: "浪週期",
-      gust: "陣風",
-      airTemperature: "氣溫",
-    },
-  },
-  ja: {
-    translation: {
-      time: "時間",
-      swellDirection: "うねり方向",
-      windDirection: "風向",
-      windSpeed: "風速",
-      swellHeight: "うねり高",
-      swellPeriod: "うねり周期",
-      gust: "突風",
-      airTemperature: "気温",
-    },
-  },
-};

package/integrations/weather/weatherService.ts

@@ -1,50 +0,0 @@
-import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
-
-const WEATHER_API_URL = "https://api.stormglass.io/v2/weather/point";
-
-export const fetchWeatherData = async ({
-  lat,
-  lng,
-  params,
-  start,
-  end,
-  source,
-}: WeatherQueryParams): Promise<WeatherApiResponse> => {
-  const paramString = params.join(",");
-
-  const query = new URLSearchParams({
-    lat: lat.toString(),
-    lng: lng.toString(),
-    params: paramString,
-  });
-
-  if (start) {
-    query.append("start", start);
-  }
-  if (end) {
-    query.append("end", end);
-  }
-  if (source) {
-    query.append("source", source);
-  }
-
-  const queryString = query.toString();
-
-  try {
-    const key = process.env.WEATHER_API_KEY;
-    const response = await fetch(`${WEATHER_API_URL}?${queryString}`, {
-      headers: {
-        Authorization: key,
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch weather data, status: ${response.status}`,
-      );
-    }
-    return response.json();
-  } catch (error) {
-    throw error; // 这里保留抛出错误，以便可以在函数调用者那里捕获异常
-  }
-};

package/integrations/weather/weatherTypes.ts

@@ -1,140 +0,0 @@
-export type WeatherParam =
-  | "time"
-  | "airTemperature"
-  | "airTemperature80m"
-  | "airTemperature100m"
-  | "airTemperature1000hpa"
-  | "airTemperature800hpa"
-  | "airTemperature500hpa"
-  | "airTemperature200hpa"
-  | "pressure"
-  | "cloudCover"
-  | "currentDirection"
-  | "currentSpeed"
-  | "gust"
-  | "humidity"
-  | "iceCover"
-  | "precipitation"
-  | "snowDepth"
-  | "seaLevel"
-  | "swellDirection"
-  | "swellHeight"
-  | "swellPeriod"
-  | "secondarySwellPeriod"
-  | "secondarySwellDirection"
-  | "secondarySwellHeight"
-  | "visibility"
-  | "waterTemperature"
-  | "waveDirection"
-  | "waveHeight"
-  | "wavePeriod"
-  | "windWaveDirection"
-  | "windWaveHeight"
-  | "windWavePeriod"
-  | "windDirection"
-  | "windDirection20m"
-  | "windDirection30m"
-  | "windDirection40m"
-  | "windDirection50m"
-  | "windDirection80m"
-  | "windDirection100m"
-  | "windDirection1000hpa"
-  | "windDirection800hpa"
-  | "windDirection500hpa"
-  | "windDirection200hpa"
-  | "windSpeed"
-  | "windSpeed20m"
-  | "windSpeed30m"
-  | "windSpeed40m"
-  | "windSpeed50m"
-  | "windSpeed80m"
-  | "windSpeed100m"
-  | "windSpeed1000hpa"
-  | "windSpeed800hpa"
-  | "windSpeed500hpa"
-  | "windSpeed200hpa";
-
-// 接口用以表达获取天气数据的请求参数
-export interface WeatherQueryParams {
-  lat: number;
-  lng: number;
-  params: WeatherParam[];
-  start?: number | string; // 可选 - 开始时间戳或ISO格式日期
-  end?: number | string; // 可选 - 结束时间戳或ISO格式日期
-  source?: string; // 可选 - 数据源
-}
-
-export interface DataSourceValue {
-  [source: string]: number | string;
-}
-
-export interface HourlyWeather {
-  time: string; // 时间点，ISO格式的日期时间字符串
-  airTemperature?: DataSourceValue; // 空气温度，不同数据源可能提供不同的数值
-  airTemperature80m?: DataSourceValue; // 80米高处的空气温度
-  airTemperature100m?: DataSourceValue; // 100米高处的空气温度
-  airTemperature1000hpa?: DataSourceValue; // 1000hpa等压面的空气温度
-  airTemperature800hpa?: DataSourceValue; // 800hpa等压面的空气温度
-  airTemperature500hpa?: DataSourceValue; // 500hpa等压面的空气温度
-  airTemperature200hpa?: DataSourceValue; // 200hpa等压面的空气温度
-  pressure?: DataSourceValue; // 气压，单位为hPa(百帕)
-  cloudCover?: DataSourceValue; // 云层覆盖率，以百分比表示
-  currentDirection?: DataSourceValue; // 海流方向，0° 表示从北方向
-  currentSpeed?: DataSourceValue; // 海流速度，单位为米每秒(m/s)
-  gust?: DataSourceValue; // 阵风，单位为米每秒(m/s)
-  humidity?: DataSourceValue; // 相对湿度, 以百分比表示
-  iceCover?: DataSourceValue; // 浮冰覆盖率，范围从 0（无冰）到 1（全覆盖）
-  precipitation?: DataSourceValue; // 降水量，单位为毫米每小时(mm/h)
-  snowDepth?: DataSourceValue; // 雪的深度，单位为米(m)
-  seaLevel?: DataSourceValue; // 海平面相对于平均海平面的高度(m)
-  swellDirection?: DataSourceValue; // 涌浪方向，0° 表示涌浪来自北方
-  swellHeight?: DataSourceValue; // 涌浪高度，单位为米(m)
-  swellPeriod?: DataSourceValue; // 涌浪周期，单位为秒(s)
-  secondarySwellPeriod?: DataSourceValue; // 副涌浪周期，单位为秒(s)
-  secondarySwellDirection?: DataSourceValue; // 副涌浪方向，0° 表示波浪来自北方
-  secondarySwellHeight?: DataSourceValue; // 副涌浪高度，单位为米(m)
-  visibility?: DataSourceValue; // 水平能见度，单位为千米(km)
-  waterTemperature?: DataSourceValue; // 水面温度，单位为摄氏度(℃)
-  waveDirection?: DataSourceValue; // 浪向，0° 表示浪向来自北方
-  waveHeight?: DataSourceValue; // 波浪高度，单位为米(m)
-  wavePeriod?: DataSourceValue; // 波浪周期，单位为秒(s)
-  windWaveDirection?: DataSourceValue; // 风浪方向，0°表示风浪来源北方
-  windWaveHeight?: DataSourceValue; // 风浪高度，单位为米(m)
-  windWavePeriod?: DataSourceValue; // 风浪周期，单位为秒(s)
-  windDirection?: DataSourceValue; // 风向, 0° 表示风来自北方
-  windDirection20m?: DataSourceValue; // 20米高处风向
-  windDirection30m?: DataSourceValue; // 30米高处风向
-  windDirection40m?: DataSourceValue; // 40米高处风向
-  windDirection50m?: DataSourceValue; // 50米高处风向
-  windDirection80m?: DataSourceValue; // 80米高处风向
-  windDirection100m?: DataSourceValue; // 100米高处风向
-  windDirection1000hpa?: DataSourceValue; // 1000hpa等压面风向
-  windDirection800hpa?: DataSourceValue; // 800hpa等压面风向
-  windDirection500hpa?: DataSourceValue; // 500hpa等压面风向
-  windDirection200hpa?: DataSourceValue; // 200hpa等压面风向
-  windSpeed?: DataSourceValue; // 10米高处的风速, 单位为米每秒(m/s)
-  windSpeed20m?: DataSourceValue; // 20米高处的风速
-  windSpeed30m?: DataSourceValue; // 30米高处的风速
-  windSpeed40m?: DataSourceValue; // 40米高处的风速
-  windSpeed50m?: DataSourceValue; // 50米高处的风速
-  windSpeed80m?: DataSourceValue; // 80米高处的风速
-  windSpeed100m?: DataSourceValue; // 100米高处的风速
-  windSpeed1000hpa?: DataSourceValue; // 1000hpa等压面的风速
-  windSpeed800hpa?: DataSourceValue; // 800hpa等压面的风速
-  windSpeed500hpa?: DataSourceValue; // 500hpa等压面的风速
-  windSpeed200hpa?: DataSourceValue; // 200hpa等压面的风速
-}
-
-export interface WeatherApiResponse {
-  hours: HourlyWeather[];
-  meta: {
-    dailyQuota: number;
-    lat: number;
-    lng: number;
-    requestCount: number;
-  };
-}
-
-export interface WeatherError {
-  message: string;
-}