@apps-in-toss/web-framework 0.0.0-dev.1740740040772 → 0.0.0-dev.1740746154601

package/dist/cli.js

@@ -0,0 +1,509 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __dirname,
+  __require,
+  loadConfig
+} from "./chunk-HL7M3JLX.js";
+
+// src/cli.ts
+import { Cli } from "clipanion";
+
+// src/BuildCommand/BuildCommand.ts
+import { Command, Option } from "clipanion";
+import picocolors from "picocolors";
+
+// src/BuildCommand/build.ts
+import fs from "fs";
+import path from "path";
+import { createArtifact } from "@apps-in-toss/framework/cli-presets";
+import * as mpack from "@react-native-bedrock/mpack-next";
+import { statusPlugin } from "@react-native-bedrock/mpack-next/plugins";
+import { execa } from "execa";
+import presets from "react-native-bedrock/presets";
+
+// src/utils/getPackageManager.ts
+function getPackageManager({ isExecutor = false } = {}) {
+  const userAgent = process.env.npm_config_user_agent;
+  const packageManagerCommands = {
+    npm: isExecutor ? "npx" : "npm",
+    pnpm: "pnpm",
+    yarn: "yarn"
+  };
+  if (!userAgent) {
+    return {
+      packageManager: packageManagerCommands["npm"],
+      version: "0.0.0"
+    };
+  }
+  const [packageManagerInfo] = userAgent.match(/(\w+)\/(\d+\.\d+\.\d+)/) || [];
+  const [packageManager, version2] = packageManagerInfo?.split("/") ?? ["npm", null];
+  if (!packageManager) {
+    return {
+      packageManager: packageManagerCommands["npm"],
+      version: "0.0.0"
+    };
+  }
+  return {
+    packageManager: packageManagerCommands[packageManager],
+    version: version2 ?? "0.0.0"
+  };
+}
+
+// src/BuildCommand/build.ts
+async function build({ distDirname, cache }) {
+  const config = await loadConfig();
+  const rootDir = process.cwd();
+  const reactNativeProjectDir = path.resolve(__dirname, "..", "react-native");
+  const projectRootTmp = path.resolve(process.cwd(), ".apps-in-toss");
+  await fs.promises.mkdir(projectRootTmp, { recursive: true });
+  await fs.promises.writeFile(
+    path.join(projectRootTmp, "metadata.json"),
+    JSON.stringify({ appName: config.appName, webPort: config.web.port })
+  );
+  const appName = config.appName;
+  const { packageManager } = getPackageManager({ isExecutor: true });
+  const distDir = path.join(rootDir, distDirname);
+  const webDistDir = path.join(distDir, "web");
+  await fs.promises.rm(distDir, { recursive: true, force: true });
+  await execa(packageManager, config.web.commands.build.split(" "), {
+    cwd: process.cwd(),
+    stdio: "inherit"
+  });
+  await fs.promises.mkdir(webDistDir, { recursive: true });
+  const items = await fs.promises.readdir(distDir);
+  for (const item of items) {
+    const src = path.join(distDir, item);
+    const dest = path.join(webDistDir, item);
+    if (src === webDistDir) {
+      continue;
+    }
+    await fs.promises.rename(src, dest);
+  }
+  const buildResults = await mpack.runBundle({
+    clean: false,
+    metafile: false,
+    dev: false,
+    rootDir: reactNativeProjectDir,
+    cache,
+    plugins: [statusPlugin],
+    config: {
+      appName,
+      services: {
+        sentry: {
+          enabled: false
+        }
+      },
+      concurrency: 2,
+      tasks: [
+        {
+          tag: `${appName}-ios`,
+          presets: [presets.service()],
+          build: {
+            babel: {
+              conditions: [(_code) => _code.includes("Ait")],
+              plugins: [
+                [
+                  __require.resolve("@apps-in-toss/babel-plugin-json"),
+                  { jsonPath: "./.apps-in-toss/metadata.json", identifierName: "Ait" }
+                ]
+              ]
+            },
+            platform: "ios",
+            entry: path.join(reactNativeProjectDir, "src", "_app.tsx"),
+            outfile: path.join(distDir, `${appName}.ios.js`)
+          }
+        },
+        {
+          tag: `${appName}-android`,
+          presets: [presets.service()],
+          build: {
+            babel: {
+              conditions: [(_code) => _code.includes("Ait")],
+              plugins: [
+                [
+                  __require.resolve("@apps-in-toss/babel-plugin-json"),
+                  { jsonPath: "./.apps-in-toss/metadata.json", identifierName: "Ait" }
+                ]
+              ]
+            },
+            platform: "android",
+            entry: path.join(reactNativeProjectDir, "src", "_app.tsx"),
+            outfile: path.join(distDir, `${appName}.android.js`)
+          }
+        }
+      ]
+    }
+  });
+  const artifactOutfile = await createArtifact({
+    buildResults,
+    rootDir,
+    reactNativeProjectDir,
+    webOutDir: webDistDir
+  });
+  if (!artifactOutfile) {
+    throw new Error("\uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uC5D0 \uC2E4\uD328\uD588\uC5B4\uC694.");
+  }
+  return artifactOutfile;
+}
+
+// src/constants.ts
+var APP_MANIFEST_NAME = "app.json";
+var DEFAULT_DIST_DIR = "dist";
+var API_BASE_URL = "https://apps-in-toss.toss.im/console";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DEFAULT_HOST = "localhost";
+
+// src/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends Command {
+  static paths = [[`build`]];
+  static usage = Command.Usage({
+    category: "Build",
+    description: "Apps In Toss \uBE4C\uB4DC \uC544\uD2F0\uD329\uD2B8\uB97C \uC0DD\uC131\uD569\uB2C8\uB2E4",
+    examples: [["\uBE4C\uB4DC \uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uD558\uAE30", "ait build"]]
+  });
+  cache = Option.Boolean("--cache", true);
+  async execute() {
+    const artifactOutfile = await build({
+      distDirname: DEFAULT_DIST_DIR,
+      cache: this.cache
+    });
+    console.log(`
+${picocolors.blue(artifactOutfile)}
+`);
+  }
+};
+
+// src/DeployCommand/DeployCommand.ts
+import assert from "assert";
+import path2 from "path";
+import * as p from "@clack/prompts";
+import { Command as Command2, Option as Option2 } from "clipanion";
+import Debug2 from "debug";
+import picocolors2 from "picocolors";
+
+// src/DeployCommand/upload.ts
+import * as fs2 from "fs";
+import Debug from "debug";
+var debug = Debug("cli:deploy");
+async function uploadArtifact(config) {
+  debug("uploadArtifact", config);
+  const response = await fetch(
+    `${API_BASE_URL}/api-public/v3/appsintossconsole/bundles/${config.appName}/sandbox/upload`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Ait-Console-Api-Key": config.apiKey
+      },
+      body: fs2.createReadStream(config.artifactPath),
+      duplex: "half"
+    }
+  );
+  return handleResponse(response);
+}
+async function handleResponse(response) {
+  debug(`Response ${response.status} ${response.statusText}`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.clone().json();
+  debug("uploadArtifact response", data);
+  if (data.resultType !== "SUCCESS") {
+    const errorCode = data?.error?.errorCode ?? "-1";
+    const errorReason = data?.error.reason ?? "unknown";
+    throw new Error(`${errorReason} (Code: ${errorCode})`);
+  }
+  const result = data.success;
+  return result.deploymentId;
+}
+
+// src/utils/readZipContent.ts
+import yauzl from "yauzl";
+function readZipContent(zipPath, fileName) {
+  return new Promise((resolve, reject) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (error, zipFile) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      zipFile.on("entry", (entry) => {
+        if (entry.fileName === fileName) {
+          zipFile.openReadStream(entry, (error2, readStream) => {
+            if (error2) {
+              throw error2;
+            }
+            let fileData = "";
+            readStream.on("data", (chunk) => fileData += chunk.toString("utf8")).on("end", () => {
+              zipFile.close();
+              resolve(fileData);
+            });
+          });
+        } else {
+          zipFile.readEntry();
+        }
+      }).on("end", () => {
+        zipFile.close();
+        reject(new Error(`'${fileName}' not found in zip file`));
+      }).on("error", (error2) => {
+        zipFile.close();
+        reject(error2);
+      });
+      zipFile.readEntry();
+    });
+  });
+}
+
+// src/DeployCommand/DeployCommand.ts
+var debug2 = Debug2("cli:deploy");
+var DeployCommand = class extends Command2 {
+  static paths = [["deploy"]];
+  apiKey = Option2.String("--api-key", {
+    required: false,
+    description: "\uC54C\uD30C \uBC30\uD3EC\uB97C \uC704\uD55C API \uD0A4"
+  });
+  async execute() {
+    const apiKey = this.apiKey || await p.password({
+      message: "\uC571\uC778\uD1A0\uC2A4 \uBC30\uD3EC API \uD0A4\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694",
+      validate: (value) => {
+        if (value.length === 0) {
+          return "API \uD0A4\uB294 \uD544\uC218 \uC785\uB825 \uD56D\uBAA9\uC785\uB2C8\uB2E4.";
+        }
+        return;
+      }
+    });
+    if (p.isCancel(apiKey)) {
+      return;
+    }
+    try {
+      const artifactOutfile = await build({
+        distDirname: DEFAULT_DIST_DIR,
+        cache: false
+      });
+      const rootDir = process.cwd();
+      const resolvedArtifactPath = path2.resolve(rootDir, artifactOutfile);
+      const appIdentifier = await readZipContent(resolvedArtifactPath, APP_MANIFEST_NAME).then((rawAppManifest) => {
+        const appManifest = JSON.parse(rawAppManifest);
+        const appIdentifier2 = appManifest.appName;
+        assert(typeof appIdentifier2 === "string", "invalid appName");
+        return appIdentifier2;
+      }).catch((error) => {
+        debug2("invalid ait file", error);
+        throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 ait \uD30C\uC77C\uC785\uB2C8\uB2E4");
+      });
+      let deploymentId = null;
+      const colorAppName = picocolors2.underline(picocolors2.cyan(appIdentifier));
+      await p.tasks([
+        {
+          title: `${colorAppName} \uC571 \uBC30\uD3EC \uC911...`,
+          task: async () => {
+            deploymentId = await uploadArtifact({
+              artifactPath: resolvedArtifactPath,
+              appName: appIdentifier,
+              apiKey
+            });
+            return `${colorAppName} \uBC30\uD3EC\uAC00 \uC644\uB8CC\uB418\uC5C8\uC5B4\uC694`;
+          }
+        }
+      ]);
+      if (deploymentId) {
+        p.note(`Deployment ID: ${picocolors2.underline(picocolors2.green(deploymentId))}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        p.log.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  }
+};
+
+// src/DevCommand/DevCommand.ts
+import fs3 from "fs";
+import path3 from "path";
+import * as mpack2 from "@react-native-bedrock/mpack-next";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import { execa as execa2 } from "execa";
+import presets2 from "react-native-bedrock/presets";
+var DevCommand = class extends Command3 {
+  static paths = [[`dev`]];
+  static usage = Command3.Usage({
+    category: "Development",
+    description: "AppsInToss \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
+    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "ait dev"]]
+  });
+  host = Option3.String("--host");
+  port = Option3.String("--port");
+  async execute() {
+    const config = await loadConfig();
+    const serverOptions = {
+      host: this.host,
+      port: this.port ? parseInt(this.port, 10) : void 0
+    };
+    const cwd = path3.resolve(__dirname, "..", "react-native");
+    const projectRootTmp = path3.resolve(process.cwd(), ".apps-in-toss");
+    await fs3.promises.mkdir(projectRootTmp, { recursive: true });
+    await fs3.promises.writeFile(
+      path3.join(projectRootTmp, "metadata.json"),
+      JSON.stringify({ appName: config.appName, webPort: config.web.port })
+    );
+    const appName = config.appName;
+    await mpack2.runServer({
+      host: serverOptions.host,
+      port: serverOptions.port,
+      enableEmbeddedReactDevTools: true,
+      enableRouterGen: false,
+      onServerReady: async () => {
+        this.context.stdout.write(
+          `Server is running on http://${serverOptions.host || DEFAULT_HOST}:${serverOptions.port || DEFAULT_LOCALHOST_PORT}
+`
+        );
+        const { packageManager } = getPackageManager({ isExecutor: true });
+        await execa2(packageManager, config.web.commands.dev.split(" "), {
+          cwd: process.cwd(),
+          stdio: "inherit"
+        });
+      },
+      cwd,
+      config: {
+        appName,
+        services: {
+          sentry: {
+            enabled: false
+          }
+        },
+        devServer: {
+          presets: [presets2.service()],
+          build: {
+            entry: "./src/_app.tsx"
+          }
+        },
+        tasks: []
+      }
+    });
+  }
+};
+
+// src/InitCommand/InitCommand.ts
+import fs4 from "fs";
+import path4 from "path";
+import * as p2 from "@clack/prompts";
+import { Command as Command4 } from "clipanion";
+import { kebabCase } from "es-toolkit";
+
+// src/InitCommand/templates/index.tsx
+var CONFIG_TEMPLATE = `import { defineConfig } from '@apps-in-toss/web-framework';
+
+export default defineConfig({
+  appName: '%%appName%%',
+  web: {
+    port: %%webPort%%,
+    commands: {
+      dev: '%%webDevCommand%%',
+      build: '%%webBuildCommand%%',
+    },
+  },
+});
+`;
+
+// src/utils/transformTemplate.ts
+function transformTemplate(templateString, values) {
+  let result = templateString;
+  for (const key in values) {
+    const placeholder = `%%${key}%%`;
+    result = result.replace(new RegExp(placeholder, "g"), values[key]);
+  }
+  return result;
+}
+
+// src/InitCommand/InitCommand.ts
+var InitCommand = class extends Command4 {
+  static paths = [[`init`]];
+  async execute() {
+    p2.intro("\u{1F680} \uC571 \uCD08\uAE30\uD654\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4");
+    const appName = await p2.text({
+      message: "Enter app name",
+      validate: (value) => {
+        if (!value) {
+          return "\uC571 \uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
+        }
+        const kebabCaseValue = kebabCase(value);
+        if (value !== kebabCaseValue) {
+          return `\uC571 \uC774\uB984\uC740 \uCF00\uBC25-\uCF00\uC774\uC2A4 \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4 (\uC608\uC2DC: ${kebabCaseValue})`;
+        }
+        return;
+      }
+    });
+    if (p2.isCancel(appName)) {
+      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+      return;
+    }
+    p2.log.step(`\uC571 \uC774\uB984\uC774 '${appName}'\uC73C\uB85C \uC124\uC815\uB418\uC5C8\uC2B5\uB2C8\uB2E4`);
+    const webPort = await p2.text({
+      message: "Enter web port",
+      placeholder: "5173",
+      defaultValue: "5173"
+    });
+    if (p2.isCancel(webPort)) {
+      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+      return;
+    }
+    p2.log.step("package.json \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uC124\uC815\uD558\uB294 \uC911...");
+    const packageJson = await fs4.promises.readFile(path4.join(process.cwd(), "package.json"), {
+      encoding: "utf-8"
+    });
+    const scripts = JSON.parse(packageJson);
+    const original = {
+      dev: scripts?.scripts?.dev || scripts?.scripts?.start,
+      build: scripts?.scripts?.build
+    };
+    scripts.scripts.dev = "ait dev";
+    scripts.scripts.build = "ait build";
+    scripts.scripts.deploy = "ait deploy";
+    await fs4.promises.writeFile(path4.join(process.cwd(), "package.json"), JSON.stringify(scripts, null, 2), {
+      encoding: "utf-8"
+    });
+    p2.log.step("apps-in-toss.config.web.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+    const config = transformTemplate(CONFIG_TEMPLATE, {
+      appName,
+      webPort,
+      webDevCommand: original.dev === "ait dev" ? "" : original.dev,
+      webBuildCommand: original.build === "ait build" ? "" : original.build
+    });
+    await fs4.promises.writeFile(path4.join(process.cwd(), "apps-in-toss.config.web.ts"), config, {
+      encoding: "utf-8"
+    });
+    p2.log.step(".gitignore \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
+    await fs4.promises.appendFile(path4.join(process.cwd(), ".gitignore"), "\n.apps-in-toss\n");
+    p2.log.step("app.json \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+    await fs4.promises.writeFile(
+      path4.join(process.cwd(), "app.json"),
+      JSON.stringify({
+        clientId: "",
+        appName,
+        permissions: []
+      }),
+      {
+        encoding: "utf-8"
+      }
+    );
+    p2.outro("\u2728 \uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4!");
+  }
+};
+
+// package.json
+var version = "0.1.6-next.6";
+
+// src/cli.ts
+var cli = new Cli({
+  binaryLabel: "apps-in-toss",
+  binaryName: "apps-in-toss",
+  binaryVersion: version,
+  enableCapture: true
+});
+cli.register(InitCommand);
+cli.register(DevCommand);
+cli.register(BuildCommand);
+cli.register(DeployCommand);
+cli.runExit(process.argv.slice(2));

package/dist/closeView.d.ts

@@ -1 +1,24 @@
+/**
+ * @public
+ * @tag BedrockModule
+ * @category BedrockModules
+ * @kind function
+ * @name closeView
+ * @description 현재 화면을 닫는 함수에요. 예를 들어, "닫기" 버튼을 눌러서 서비스를 종료할 때 사용할 수 있어요.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ### 닫기 버튼을 눌러 화면 닫기
+ *
+ * ```tsx
+ * 
+ * import { closeView } from '@apps-in-toss/web-framework';
+ *
+ * function CloseButton() {
+ *  return <input type="button" value="닫기" onClick={closeView} />;
+ * }
+ * ```
+ */
+export declare function closeView(): Promise<void>;
+
 export {};

package/dist/generateHapticFeedback.d.ts

@@ -1 +1,52 @@
+export type HapticFeedbackType = "tickWeak" | "tap" | "tickMedium" | "softMedium" | "basicWeak" | "basicMedium" | "success" | "error" | "wiggle" | "confetti";
+/**
+* @public
+* @tag HapticFeedbackType
+* @category Types
+* @name HapticFeedbackOptions
+* @description
+* generateHapticFeedback 함수에 전달할 햅틱진동의 타입을 나타내요. 진동타입의 종류는 다음과 같아요.
+* ```typescript
+* type HapticFeedbackType =
+* | "tickWeak"
+* | "tap"
+* | "tickMedium"
+* | "softMedium"
+* | "basicWeak"
+* | "basicMedium"
+* | "success"
+* | "error"
+* | "wiggle"
+* | "confetti";
+* ```
+* @typedef { type: HapticFeedbackType } HapticFeedbackOptions
+* @typedef { "tickWeak" | "tap" | "tickMedium" | "softMedium" | "basicWeak" | "basicMedium" | "success" | "error" | "wiggle" | "confetti" } HapticFeedbackType
+*
+*/
+export interface HapticFeedbackOptions {
+	type: HapticFeedbackType;
+}
+/**
+ * @public
+ * @tag BedrockModule
+ * @category BedrockModules
+ * @kind function
+ * @name generateHapticFeedback
+ * @description 디바이스에 햅틱 진동을 일으키는 함수예요. 예를 들어, 버튼 터치나 화면전환에 드라마틱한 효과를 주고 싶을 때 사용할 수 있어요. [HapticFeedbackOptions](../Types/HapticFeedbackOptions.html)에서 진동타입을 확인해 보세요.
+ * @returns {void}
+ *
+ * @example
+ * ### 버튼을 눌러 햅틱 일으키기
+ *
+ * ```tsx
+ * 
+ * import { generateHapticFeedback } from '@apps-in-toss/web-framework';
+ *
+ * function GenerateHapticFeedback() {
+ *  return <input type="button" value="햅틱" onClick={() => { generateHapticFeedback( { type: "tickWeak"}) }} />;
+ * }
+ * ```
+ */
+export declare function generateHapticFeedback(options: HapticFeedbackOptions): Promise<void>;
+
 export {};

package/dist/getDeviceId.d.ts

@@ -1 +1,32 @@
+/**
+ * @public
+ * @tag BedrockModule
+ * @category BedrockModules
+ * @kind function
+ * @name getDeviceId
+ * @description
+ * 사용 중인 기기의 고유 식별자를 문자열로 반환해요.
+ *
+ * 이 함수는 현재 사용 중인 기기의 고유 식별자를 문자열로 반환해요. 기기별로 설정이나 데이터를 저장하거나 사용자의 기기를 식별해서 로그를 기록하고 분석하는 데 사용할 수 있어요. 같은 사용자의 여러 기기를 구분하는 데도 유용해요.
+ *
+ * @returns {string} 기기의 고유 식별자를 나타내는 문자열이에요.
+ *
+ * @example
+ * ### 기기 고유 식별자 가져오기
+ *
+ * ```tsx
+ * import { getDeviceId } from '@apps-in-toss/web-framework';
+ * 
+ *
+ * function MyPage() {
+ *   const id = getDeviceId();
+ *
+ *   return (
+ *     <span>사용자의 기기 고유 식별자: {id}</span>
+ *   );
+ * }
+ * ```
+ */
+export declare function getDeviceId(): string;
+
 export {};

package/dist/getLocale.d.ts

@@ -1 +1,31 @@
+/**
+ * @public
+ * @tag BedrockModule
+ * @category BedrockModules
+ * @kind function
+ * @name getLocale
+ * @description
+ * 사용자의 로케일(locale) 정보를 반환해요. 네이티브 모듈에서 로케일 정보를 가져올 수 없을 때는 기본값으로 'ko-KR'을 반환합니다. 앱의 현지화 및 언어 설정과 관련된 기능을 구현할 때 사용하세요.
+ *
+ * @returns {string} 사용자의 로케일 정보를 반환해요.
+ *
+ * @example
+ * ### 현재 사용자의 로케일 정보 가져오기
+ *
+ * ```tsx
+ * import { getLocale } from '@apps-in-toss/web-framework';
+ * 
+ *
+ * function MyPage() {
+ *  const locale = getLocale();
+ *
+ *  return (
+ *    <span>사용자의 로케일 정보: {locale}</span>
+ *  )
+ * }
+ *
+ * ```
+ */
+export declare function getLocale(): string;
+
 export {};

package/dist/getNetworkStatus.d.ts

@@ -1 +1,55 @@
+export type NetworkStatus = "OFFLINE" | "WIFI" | "2G" | "3G" | "4G" | "5G" | "WWAN" | "UNKNOWN";
+/**
+ * @public
+ * @tag BedrockModule
+ * @category BedrockModules
+ * @kind function
+ * @name getNetworkStatus
+ * @description
+ * 디바이스의 현재 네트워크 연결 상태를 가져오는 함수예요.
+ * 반환 값은 `NetworkStatus` 타입으로, 인터넷 연결 여부와 연결 유형(Wi-Fi, 모바일 데이터 등)을 나타내요. 값은 다음 중 하나예요.
+ *
+ * - `OFFLINE`: 인터넷에 연결되지 않은 상태예요.
+ * - `WIFI`: Wi-Fi에 연결된 상태예요.
+ * - `2G`: 2G 네트워크에 연결된 상태예요.
+ * - `3G`: 3G 네트워크에 연결된 상태예요.
+ * - `4G`: 4G 네트워크에 연결된 상태예요.
+ * - `5G`: 5G 네트워크에 연결된 상태예요.
+ * - `WWAN`: 인터넷은 연결되었지만, 연결 유형(Wi-Fi, 2G~5G)을 알 수 없는 상태예요. 이 상태는 iOS에서만 확인할 수 있어요.
+ * - `UNKNOWN`: 인터넷 연결 상태를 알 수 없는 상태예요. 이 상태는 안드로이드에서만 확인할 수 있어요.
+ *
+ * @returns {Promise<NetworkStatus>} 네트워크 상태를 반환해요.
+ *
+ * @example
+ * ### 현재 네트워크 상태 가져오기
+ *
+ * 네트워크 연결 상태를 가져와 화면에 표시하는 예제예요.
+ *
+ * ```tsx
+ * import { useState, useEffect } from 'react';
+ * 
+ * import { getNetworkStatus, NetworkStatus } from '@apps-in-toss/web-framework';
+ *
+ * function GetNetworkStatus() {
+ *   const [status, setStatus] = useState<NetworkStatus | ''>('');
+ *
+ *   useEffect(() => {
+ *     async function fetchStatus() {
+ *       const networkStatus = await getNetworkStatus();
+ *       setStatus(networkStatus);
+ *     }
+ *
+ *     fetchStatus();
+ *   }, []);
+ *
+ *   return (
+ *     <div>
+ *       <span>현재 네트워크 상태: {status}</span>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function getNetworkStatus(): Promise<NetworkStatus>;
+
 export {};