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

package/dist/{index.d.cts → config/index.d.cts}

@@ -1,3 +1,5 @@
+import { Permission } from '@apps-in-toss/framework/plugins';
+import { BedrockConfigResponse } from 'react-native-bedrock/config';
 import { z } from 'zod';
 
 declare const AppsInTossConfigSchema: z.ZodObject<{
@@ -27,6 +29,7 @@ declare const AppsInTossConfigSchema: z.ZodObject<{
             build: string;
         };
     }>;
+    permissions: z.ZodArray<z.ZodType<Permission, z.ZodTypeDef, Permission>, "many">;
 }, "strip", z.ZodTypeAny, {
     appName: string;
     web: {
@@ -36,6 +39,7 @@ declare const AppsInTossConfigSchema: z.ZodObject<{
             build: string;
         };
     };
+    permissions: Permission[];
 }, {
     appName: string;
     web: {
@@ -45,10 +49,9 @@ declare const AppsInTossConfigSchema: z.ZodObject<{
             build: string;
         };
     };
+    permissions: Permission[];
 }>;
 type AppsInTossConfig = z.infer<typeof AppsInTossConfigSchema>;
-declare const defineConfig: (config: z.input<typeof AppsInTossConfigSchema>) => AppsInTossConfig;
+declare const defineConfig: (config: z.input<typeof AppsInTossConfigSchema>) => Promise<BedrockConfigResponse>;
 
-declare const loadConfig: () => Promise<AppsInTossConfig>;
-
-export { type AppsInTossConfig, defineConfig, loadConfig };
+export { type AppsInTossConfig, defineConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,57 @@
+import { Permission } from '@apps-in-toss/framework/plugins';
+import { BedrockConfigResponse } from 'react-native-bedrock/config';
+import { z } from 'zod';
+
+declare const AppsInTossConfigSchema: z.ZodObject<{
+    appName: z.ZodString;
+    web: z.ZodObject<{
+        port: z.ZodNumber;
+        commands: z.ZodObject<{
+            dev: z.ZodString;
+            build: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            dev: string;
+            build: string;
+        }, {
+            dev: string;
+            build: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        commands: {
+            dev: string;
+            build: string;
+        };
+    }, {
+        port: number;
+        commands: {
+            dev: string;
+            build: string;
+        };
+    }>;
+    permissions: z.ZodArray<z.ZodType<Permission, z.ZodTypeDef, Permission>, "many">;
+}, "strip", z.ZodTypeAny, {
+    appName: string;
+    web: {
+        port: number;
+        commands: {
+            dev: string;
+            build: string;
+        };
+    };
+    permissions: Permission[];
+}, {
+    appName: string;
+    web: {
+        port: number;
+        commands: {
+            dev: string;
+            build: string;
+        };
+    };
+    permissions: Permission[];
+}>;
+type AppsInTossConfig = z.infer<typeof AppsInTossConfigSchema>;
+declare const defineConfig: (config: z.input<typeof AppsInTossConfigSchema>) => Promise<BedrockConfigResponse>;
+
+export { type AppsInTossConfig, defineConfig };

package/dist/config/index.js

@@ -0,0 +1,290 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __dirname,
+  appsInTossWeb,
+  init_esm_shims
+} from "../chunk-LJBVSTWE.js";
+
+// src/config/index.ts
+init_esm_shims();
+
+// src/config/defineConfig.ts
+init_esm_shims();
+import path3 from "path";
+
+// ../../.yarn/cache/find-up-npm-7.0.0-a80086f7af-e6ee3e6154.zip/node_modules/find-up/index.js
+init_esm_shims();
+import path2 from "node:path";
+
+// ../../.yarn/cache/locate-path-npm-7.2.0-454f209f37-139e8a7fe1.zip/node_modules/locate-path/index.js
+init_esm_shims();
+import process from "node:process";
+import path from "node:path";
+import fs, { promises as fsPromises } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// ../../.yarn/cache/p-locate-npm-6.0.0-d73b86f7fc-d72fa2f41a.zip/node_modules/p-locate/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/p-limit-npm-4.0.0-6161fa2142-a56af34a77.zip/node_modules/p-limit/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/yocto-queue-npm-1.1.1-3796fef980-cb287fe5e6.zip/node_modules/yocto-queue/index.js
+init_esm_shims();
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// ../../.yarn/cache/p-limit-npm-4.0.0-6161fa2142-a56af34a77.zip/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// ../../.yarn/cache/p-locate-npm-6.0.0-d73b86f7fc-d72fa2f41a.zip/node_modules/p-locate/index.js
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+
+// ../../.yarn/cache/locate-path-npm-7.2.0-454f209f37-139e8a7fe1.zip/node_modules/locate-path/index.js
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = process.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+
+// ../../.yarn/cache/unicorn-magic-npm-0.1.0-352b6e3681-e4ed0de05b.zip/node_modules/unicorn-magic/node.js
+init_esm_shims();
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function toPath2(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+}
+
+// ../../.yarn/cache/path-exists-npm-5.0.0-126b43894b-b170f3060b.zip/node_modules/path-exists/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/find-up-npm-7.0.0-a80086f7af-e6ee3e6154.zip/node_modules/find-up/index.js
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options = {}) {
+  let directory = path2.resolve(toPath2(options.cwd) ?? "");
+  const { root } = path2.parse(directory);
+  const stopAt = path2.resolve(directory, toPath2(options.stopAt ?? root));
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+
+// src/config/defineConfig.ts
+import { defineConfig as originDefineConfig } from "react-native-bedrock/config";
+import { z } from "zod";
+var AppsInTossConfigSchema = z.object({
+  appName: z.string(),
+  web: z.object({
+    port: z.number(),
+    commands: z.object({
+      dev: z.string(),
+      build: z.string()
+    })
+  }),
+  permissions: z.array(z.custom())
+});
+var defineConfig = async (config) => {
+  const reactNativeProjectDir = await findUp("react-native", { type: "directory", cwd: __dirname });
+  if (!reactNativeProjectDir) {
+    throw new Error("react-native \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  }
+  return originDefineConfig({
+    appName: config.appName,
+    plugins: [
+      appsInTossWeb({
+        port: config.web.port,
+        commands: config.web.commands,
+        permissions: config.permissions
+      })
+    ],
+    cwd: reactNativeProjectDir,
+    entryFile: path3.join(reactNativeProjectDir, "src", "_app.tsx")
+  });
+};
+export {
+  defineConfig
+};

package/dist/fetchAlbumPhotos.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 사진 조회 결과를 나타내는 타입이에요.
+ */
+export interface ImageResponse {
+	/** 가져온 사진의 고유 ID예요. */
+	id: string;
+	/** 사진의 데이터 URI예요. `base64` 옵션이 `true`인 경우 Base64 문자열로 반환돼요. */
+	dataUri: string;
+}
+/**
+ * 앨범 사진을 조회할 때 사용하는 옵션 타입이에요.
+ */
+export interface FetchAlbumPhotosOptions {
+	/** 가져올 사진의 최대 개수를 설정해요. 숫자를 입력하고 기본값은 10이에요. */
+	maxCount?: number;
+	/** 사진의 최대 폭을 제한해요. 단위는 픽셀이고 기본값은 1024이에요. */
+	maxWidth?: number;
+	/** 이미지를 base64 형식으로 반환할지 설정해요. 기본값은 `false`예요. */
+	base64?: boolean;
+}
+/**
+ * @public
+ * @tag AppsInTossModule
+ * @category AppsInTossModules
+ * @kind function
+ * @name fetchAlbumPhotos
+ * @description
+ * 사용자의 앨범에서 사진 목록을 불러오는 함수예요.
+ * 최대 개수와 해상도를 설정할 수 있고 갤러리 미리보기, 이미지 선택 기능 등에 활용할 수 있어요.
+ *
+ * @param options - 조회 옵션을 담은 객체예요.
+ * @param {number} [options.maxCount=10] 가져올 사진의 최대 개수를 설정해요. 숫자로 입력하며 기본값은 10이에요.
+ * @param {number} [options.maxWidth=1024] 사진의 최대 폭을 제한해요. 단위는 픽셀이며 기본값은 `1024`이에요.
+ * @param {boolean} [options.base64=false] 이미지를 base64 형식으로 반환할지 설정해요. 기본값은 `false`예요.
+ * @returns {Promise<AlbumResponse[]>}
+ * 앨범 사진의 고유 ID와 데이터 URI를 포함한 배열을 반환해요.
+ *
+ * @example
+ * ### 사진의 최대 폭을 360px로 제한하여 가져오기
+ *
+ * ```tsx
+ * import React, { useState } from 'react';
+ * 
+ * import { fetchAlbumPhotos } from '@apps-in-toss/web-framework';
+ *
+ * // 앨범 사진 목록을 가져와 화면에 표시하는 컴포넌트
+ * function AlbumPhotoList() {
+ *   const [albumPhotos, setAlbumPhotos] = useState([]);
+ *
+ *   const handlePress = async () => {
+ *     try {
+ *       const response = await fetchAlbumPhotos({
+ *         base64: true,
+ *         maxWidth: 360,
+ *       });
+ *       setAlbumPhotos((prev) => ([...prev, ...response]));
+ *     } catch (error) {
+ *       console.error('앨범을 가져오는 데 실패했어요:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {albumPhotos.map((image) => (
+ *         <img src={`data:image/jpeg;base64,${image.dataUri}`} key={image.id} />
+ *       ))}
+ *       <input type="button" value="앨범 가져오기" onClick={handlePress} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function fetchAlbumPhotos(options: FetchAlbumPhotosOptions): Promise<ImageResponse[]>;
+
+export {};

package/dist/fetchContacts.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 연락처 정보를 나타내는 타입이에요.
+ */
+export interface ContactEntity {
+	/** 연락처 이름이에요. */
+	name: string;
+	/** 연락처 전화번호로, 문자열 형식이에요. */
+	phoneNumber: string;
+}
+/**
+ * @public
+ * @tag AppsInTossModule
+ * @category AppsInTossModules
+ * @kind function
+ * @name fetchContacts
+ * @description 사용자의 연락처 목록을 페이지 단위로 가져오는 함수예요.
+ * @param size - 한 번에 가져올 연락처 개수예요. 예를 들어, 10을 전달하면 최대 10개의 연락처를 가져와요.
+ * @param offset - 가져올 연락처의 시작 지점이에요. 처음 호출할 때는 `0`을 전달해야 해요. 이후에는 이전 호출에서 반환된 `nextOffset` 값을 사용해요.
+ * @param query - 추가적인 필터링 옵션이에요.
+ * @param query.contains - 이름에 특정 문자열이 포함된 연락처만 가져오고 싶을 때 사용해요. 이 값을 전달하지 않으면 모든 연락처를 가져와요.
+ * @returns {Promise<{result: { name: string; phoneNumber: string }[]; nextOffset: number | null; done: boolean}>}
+ * 연락처 목록과 페이지네이션 정보를 포함한 객체를 반환해요.
+ * - `result`: 가져온 연락처 목록이에요.
+ * - `nextOffset`: 다음 호출에 사용할 오프셋 값이에요. 더 가져올 연락처가 없으면 `null`이에요.
+ * - `done`: 모든 연락처를 다 가져왔는지 여부를 나타내요. 모두 가져왔다면 `true`예요.
+ *
+ * @example
+ * ### 특정 문자열이 포함된 연락처 목록 가져오기
+ *
+ * ```tsx
+ * import React, { useState } from 'react';
+ * 
+ * import { fetchContacts } from '@apps-in-toss/web-framework';
+ *
+ * // 특정 문자열을 포함한 연락처 목록을 가져와 화면에 표시하는 컴포넌트
+ * function ContactsList() {
+ *   const [contacts, setContacts] = useState({
+ *     result: [],
+ *     nextOffset: null,
+ *     done: false,
+ *   });
+ *
+ *   const handlePress = async () => {
+ *     try {
+ *       if (contacts.done) {
+ *         console.log('모든 연락처를 가져왔어요.');
+ *         return;
+ *       }
+ *
+ *       const response = await fetchContacts({
+ *         size: 10,
+ *         offset: contacts.nextOffset ?? 0,
+ *         query: { contains: '홍길동' },
+ *       });
+ *       setContacts((prev) => ({
+ *         result: [...prev.result, ...response.result],
+ *         nextOffset: response.nextOffset,
+ *         done: response.done,
+ *       }));
+ *     } catch (error) {
+ *       console.error('연락처를 가져오는 데 실패했어요:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {contacts.result.map((contact, index) => (
+ *         <span key={index}>{contact.name}: {contact.phoneNumber}</span>
+ *       ))}
+ *       <input type="button"
+ *         value={contacts.done ? '모든 연락처를 가져왔어요.' : '다음 연락처 가져오기'}
+ *         disabled={contacts.done}
+ *         onClick={handlePress}
+ *       />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function fetchContacts({ size, offset, query, }: {
+	size: number;
+	offset: number;
+	query?: {
+		contains?: string;
+	};
+}): Promise<{
+	result: ContactEntity[];
+	nextOffset: number | null;
+	done: boolean;
+}>;
+
+export {};

package/dist/generateHapticFeedback.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/getClipboardText.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @public
+ * @tag AppsInTossModule
+ * @category AppsInTossModules
+ * @kind function
+ * @name getClipboardText
+ * @description 클립보드에 저장된 텍스트를 가져오는 함수예요. 복사된 텍스트를 읽어서 다른 작업에 활용할 수 있어요.
+ * @returns {Promise<string>} - 클립보드에 저장된 텍스트를 반환해요. 클립보드에 텍스트가 없으면 빈 문자열을 반환해요.
+ *
+ * @example
+ * ### 클립보드의 텍스트 가져오기
+ *
+ * ```tsx
+ * import React, { useState } from 'react';
+ * 
+ * import { getClipboardText } from '@apps-in-toss/web-framework';
+ *
+ * // '붙여넣기' 버튼을 누르면 클립보드에 저장된 텍스트를 가져와 화면에 표시해요.
+ * function PasteButton() {
+ *   const [text, setText] = useState('');
+ *
+ *   const handlePress = async () => {
+ *     try {
+ *       const clipboardText = await getClipboardText();
+ *       setText(clipboardText || '클립보드에 텍스트가 없어요.');
+ *     } catch (error) {
+ *       console.error('클립보드에서 텍스트를 가져오지 못했어요:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <span>{text}</span>
+ *       <input type="button" value="붙여넣기" onClick={handlePress} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function getClipboardText(): Promise<string>;
+
+export {};

package/dist/getCurrentLocation.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 위치 정확도 옵션이에요.
+ */
+export enum Accuracy {
+	/**
+	 * 오차범위 3KM 이내
+	 */
+	Lowest = 1,
+	/**
+	 * 오차범위 1KM 이내
+	 */
+	Low,
+	/**
+	 * 오차범위 몇 백미터 이내
+	 */
+	Balanced,
+	/**
+	 * 오차범위 10M 이내
+	 */
+	High,
+	/**
+	 * 가장 높은 정확도
+	 */
+	Highest,
+	/**
+	 * 네비게이션을 위한 최고 정확도
+	 */
+	BestForNavigation
+}
+export interface Location {
+	/**
+	 * Android에서만 지원하는 옵션이에요.
+	 *
+	 * - `FINE`: 정확한 위치
+	 * - `COARSE`: 대략적인 위치
+	 *
+	 * @see https://developer.android.com/codelabs/approximate-location
+	 */
+	accessLocation?: "FINE" | "COARSE";
+	/**
+	 * 위치가 업데이트된 시점의 유닉스 타임스탬프예요.
+	 */
+	timestamp: number;
+	coords: {
+		latitude: number; // 위도
+		longitude: number; // 경도
+		altitude: number; // 높이
+		accuracy: number; // 위치 정확도 (미터)
+		altitudeAccuracy: number; // 고도 정확도 (미터)
+		heading: number; // 방향 (북: 0°, 동: 90°, 남: 180°, 서: 270°)
+	};
+}
+export interface GetCurrentLocationOptions {
+	/**
+	 * 위치 정보를 가져올 정확도 수준이에요.
+	 */
+	accuracy: Accuracy;
+}
+/**
+ * @public
+ * @tag AppsInTossModule
+ * @category AppsInTossModules
+ * @kind function
+ * @name getCurrentLocation
+ * @description 디바이스의 현재 위치 정보를 가져오는 함수예요.
+ * 위치 기반 서비스를 구현할 때 사용되고, 한 번만 호출되어 현재 위치를 즉시 반환해요.
+ * 예를 들어 지도 앱에서 사용자의 현재 위치를 한 번만 가져올 때, 날씨 앱에서 사용자의 위치를 기반으로 기상 정보를 제공할 때, 매장 찾기 기능에서 사용자의 위치를 기준으로 가까운 매장을 검색할 때 사용하면 유용해요.
+ *
+ * @param {GetCurrentLocationOptions} options 위치 정보를 가져올 때 사용하는 옵션 객체예요.
+ * @param {Accuracy} [options.accuracy] 위치 정보의 정확도 수준이에요. 정확도는 `Accuracy` 타입으로 설정돼요.
+ * @returns {Promise<Location>} 디바이스의 위치 정보가 담긴 객체를 반환해요.
+ *
+ * @example
+ * ### 디바이스의 현재 위치 정보 가져오기
+ *
+ * ```tsx
+ * import React, { useState } from 'react';
+ * 
+ * import { getCurrentLocation } from '@apps-in-toss/web-framework';
+ *
+ * // 현재 위치 정보를 가져와 화면에 표시하는 컴포넌트
+ * function CurrentPosition() {
+ *   const [position, setPosition] = useState(null);
+ *
+ *   const handlePress = async () => {
+ *     try {
+ *       const response = await getCurrentLocation({ accuracy: Accuracy.Balanced });
+ *       setPosition(response);
+ *     } catch (error) {
+ *       console.error('위치 정보를 가져오는 데 실패했어요:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {position ? (
+ *         <span>위치: {position.coords.latitude}, {position.coords.longitude}</span>
+ *       ) : (
+ *         <span>위치 정보를 아직 가져오지 않았어요</span>
+ *       )}
+ *       <input type="button" value="현재 위치 정보 가져오기" onClick={handlePress} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function getCurrentLocation(options: GetCurrentLocationOptions): Promise<Location>;
+
+export {};