@react-native-kakao/user 3.1.0-next.0 → 3.1.0-next.2

package/src/index.ts

@@ -1,5 +1,5 @@
 import { is } from '@mj-studio/js-util';
-import { kAssert } from '@react-native-kakao/core';
+import { kAssert, kCreateWebError } from '@react-native-kakao/core';
 
 import Native from './spec/NativeKakaoUser';
 import { validateShippingAddressOptions } from './validateShippingAddressOptions';
@@ -15,13 +15,28 @@ export interface KakaoLoginToken {
   refreshTokenExpiresIn: number;
   scopes: string[];
 }
+export type KakaoCodeTokenOptions = {
+  code: string;
+  codeVerifier?: string;
+  redirectUri?: string;
+  web?: { clientSecret?: string };
+};
+
+const minActivityRequestCode = -2147483648;
+const maxActivityRequestCode = 2147483647;
+
+export type KakaoTalkLaunchMethod = 'UniversalLink' | 'CustomScheme';
+
+const defaultTalkLaunchMethod: KakaoTalkLaunchMethod = 'UniversalLink';
+const webOnlyErrorCode = 'Package-UnsupportedPlatform';
+
 export interface KakaoScopeInfo {
   id: string;
   agreed: boolean;
   displayName: string;
-  revocable?: boolean;
+  revocable?: boolean | null;
   using: boolean;
-  delegated?: boolean;
+  delegated?: boolean | null;
   type: string;
 }
 export interface KakaoServiceTerms {
@@ -30,6 +45,7 @@ export interface KakaoServiceTerms {
   agreed: boolean;
   required: boolean;
   revocable: boolean;
+  agreedBy?: 'KAUTH' | 'KAPI' | 'unknown';
 }
 export type KakaoRevokedServiceTerms = {
   tag: string;
@@ -61,34 +77,45 @@ export interface KakaoShippingAddress {
 }
 export interface KakaoUser {
   id: number;
-  email: string;
+  properties: Record<string, string>;
+  hasSignedUp?: boolean | null;
+  uuid?: string | null;
+  groupUserToken?: string | null;
+  email?: string | null;
   name?: string | null;
-  nickname: string;
-  profileImageUrl: string;
-  thumbnailImageUrl: string;
+  nickname?: string | null;
+  profileImageUrl?: string | null;
+  thumbnailImageUrl?: string | null;
+  isDefaultImage?: boolean | null;
   phoneNumber?: string | null;
   ageRange?: string | null;
   birthday?: string | null;
   birthdayType?: string | null;
+  isLeapMonth?: boolean | null;
   birthyear?: string | null;
   gender?: string | null;
-  isEmailValid: boolean;
-  isEmailVerified: boolean;
-  isKorean?: boolean;
-  ageRangeNeedsAgreement?: boolean;
-  birthdayNeedsAgreement?: boolean;
-  birthyearNeedsAgreement?: boolean;
-  emailNeedsAgreement?: boolean;
-  genderNeedsAgreement?: boolean;
-  isKoreanNeedsAgreement?: boolean;
-  phoneNumberNeedsAgreement?: boolean;
-  profileNeedsAgreement?: boolean;
-  nameNeedsAgreement?: boolean;
-  profileImageNeedsAgreement?: boolean;
-  profileNicknameNeedsAgreement?: boolean;
-  legalBirthDateNeedsAgreement?: boolean;
-  connectedAt?: number;
-  synchedAt?: number;
+  isEmailValid?: boolean | null;
+  isEmailVerified?: boolean | null;
+  isKorean?: boolean | null;
+  ageRangeNeedsAgreement?: boolean | null;
+  birthdayNeedsAgreement?: boolean | null;
+  birthyearNeedsAgreement?: boolean | null;
+  emailNeedsAgreement?: boolean | null;
+  genderNeedsAgreement?: boolean | null;
+  isKoreanNeedsAgreement?: boolean | null;
+  phoneNumberNeedsAgreement?: boolean | null;
+  profileNeedsAgreement?: boolean | null;
+  nameNeedsAgreement?: boolean | null;
+  profileImageNeedsAgreement?: boolean | null;
+  profileNicknameNeedsAgreement?: boolean | null;
+  legalName?: string | null;
+  legalNameNeedsAgreement?: boolean | null;
+  legalBirthDate?: string | null;
+  legalBirthDateNeedsAgreement?: boolean | null;
+  legalGender?: 'female' | 'male' | null;
+  legalGenderNeedsAgreement?: boolean | null;
+  connectedAt?: number | null;
+  synchedAt?: number | null;
 }
 export interface KakaoAccessTokenInfo {
   id?: number;
@@ -101,12 +128,20 @@ export function login({
   useKakaoAccountLogin,
   scopes,
   nonce,
+  loginHint,
+  channelPublicIds,
+  android,
+  ios,
 }: {
   serviceTerms?: string[];
   prompts?: ('Login' | 'Create' | 'Cert' | 'SelectAccount')[];
   scopes?: string[];
   useKakaoAccountLogin?: boolean;
   nonce?: string;
+  loginHint?: string;
+  channelPublicIds?: string[];
+  android?: { requestCode?: number };
+  ios?: { launchMethod?: KakaoTalkLaunchMethod };
   web?: {
     redirectUri: string;
     scope?: string[];
@@ -118,31 +153,133 @@ export function login({
     nonce?: string;
   };
 } = {}): Promise<KakaoLoginToken> {
+  const requestCode = android?.requestCode;
+  kAssert(
+    requestCode == null ||
+      (Number.isInteger(requestCode) &&
+        requestCode >= minActivityRequestCode &&
+        requestCode <= maxActivityRequestCode),
+    `[login] android.requestCode must be an integer from ${minActivityRequestCode} to ${maxActivityRequestCode}`,
+  );
+
   kAssert(
     !useKakaoAccountLogin ? !is.notEmptyArray(prompts) && !is.notEmptyArray(scopes) : true,
     '[login] `prompts` and `scopes` cannot be passed if useKakaoAccountLogin is false.',
   );
 
   kAssert(
-    is.notEmptyArray(scopes) ? !is.notEmptyArray(prompts) && !is.notEmptyArray(serviceTerms) : true,
-    '[login] `scopes` cannot be passed with `prompts` or `serviceTerms`',
+    is.notEmptyArray(scopes)
+      ? !is.notEmptyArray(prompts) &&
+          !is.notEmptyArray(serviceTerms) &&
+          !is.notEmptyArray(channelPublicIds)
+      : true,
+    '[login] `scopes` cannot be passed with `prompts`, `serviceTerms`, or `channelPublicIds`',
+  );
+
+  kAssert(
+    loginHint == null ||
+      (!is.notEmptyArray(scopes) &&
+        !is.notEmptyArray(serviceTerms) &&
+        !is.notEmptyArray(channelPublicIds)),
+    '[login] `loginHint` cannot be passed with `scopes`, `serviceTerms`, or `channelPublicIds` on native platforms.',
   );
 
   return Native.login(
     serviceTerms ?? [],
     prompts ?? [],
     useKakaoAccountLogin ?? false,
+    ios?.launchMethod ?? defaultTalkLaunchMethod,
     scopes ?? [],
     nonce,
+    loginHint,
+    channelPublicIds ?? [],
+    requestCode,
   );
 }
 
-export function logout() {
-  return Native.logout();
+export async function signup({ properties }: { properties?: Record<string, string> } = {}) {
+  await Native.signup(properties);
 }
 
-export function unlink() {
-  return Native.unlink();
+export function loginWithKakao({
+  uiMode = 'auto',
+  prompts,
+  loginHint,
+  nonce,
+  channelPublicIds,
+  serviceTerms,
+  ios,
+}: {
+  uiMode?: 'auto' | 'light' | 'dark';
+  prompts?: ('Login' | 'Create' | 'Cert' | 'SelectAccount')[];
+  loginHint?: string;
+  nonce?: string;
+  channelPublicIds?: string[];
+  serviceTerms?: string[];
+  ios?: {
+    orientation?: 'auto' | 'portrait' | 'landscape';
+    launchMethod?: KakaoTalkLaunchMethod;
+  };
+} = {}): Promise<KakaoLoginToken> {
+  return Native.loginWithKakao(
+    uiMode,
+    ios?.orientation ?? 'auto',
+    ios?.launchMethod ?? defaultTalkLaunchMethod,
+    prompts ?? [],
+    loginHint,
+    nonce,
+    channelPublicIds ?? [],
+    serviceTerms ?? [],
+  );
+}
+
+export function refreshToken({
+  token,
+  ios,
+}: {
+  token?: KakaoLoginToken;
+  ios?: { loggingEnabled?: boolean };
+} = {}): Promise<KakaoLoginToken> {
+  kAssert(
+    ios?.loggingEnabled == null || typeof ios.loggingEnabled === 'boolean',
+    '[refreshToken] ios.loggingEnabled must be a boolean',
+  );
+
+  if (token !== undefined) {
+    kAssert(
+      token != null &&
+        is.string(token.accessToken) &&
+        token.accessToken.length > 0 &&
+        is.string(token.refreshToken) &&
+        token.refreshToken.length > 0,
+      '[refreshToken] token must contain non-empty accessToken and refreshToken strings',
+    );
+
+    kAssert(
+      [token.accessTokenExpiresAt, token.refreshTokenExpiresAt].every(
+        (value) => Number.isFinite(value) && !Number.isNaN(new Date(value * 1000).getTime()),
+      ) && [token.accessTokenExpiresIn, token.refreshTokenExpiresIn].every(Number.isFinite),
+      '[refreshToken] token expiry timestamps must be valid Unix seconds and lifetimes must be finite',
+    );
+
+    kAssert(
+      (token.tokenType == null || is.string(token.tokenType)) &&
+        (token.idToken == null || is.string(token.idToken)) &&
+        Array.isArray(token.scopes) &&
+        token.scopes.every((scope) => is.string(scope)),
+      '[refreshToken] tokenType and idToken must be strings when present, and scopes must be strings',
+    );
+  }
+
+  return Native.refreshToken(token, ios?.loggingEnabled ?? true);
+}
+
+export async function logout() {
+  await Native.logout();
+}
+
+export async function unlink() {
+  await Native.unlink();
 }
 
 export function isLogined() {
@@ -159,7 +296,11 @@ export function scopes(scopes?: string[]): Promise<KakaoScopeInfo[]> {
   return Native.scopes(scopes);
 }
 
-export function revokeScopes(scopes: string[]): Promise<void> {
+export async function revokeScopes(scopes: string[]): Promise<void> {
+  await Native.revokeScopes(scopes);
+}
+
+export function revokeScopesWithResult(scopes: string[]): Promise<KakaoScopeInfo[]> {
   return Native.revokeScopes(scopes);
 }
 
@@ -195,21 +336,49 @@ export function selectShippingAddress(): Promise<number> {
   return Native.selectShippingAddress();
 }
 
-export function me(): Promise<KakaoUser> {
-  return Native.me();
+export function me({
+  propertyKeys,
+  secureResource = true,
+}: { propertyKeys?: string[]; secureResource?: boolean } = {}): Promise<KakaoUser> {
+  return Native.me(propertyKeys, secureResource);
+}
+
+export async function issueAccessTokenWithCode({
+  code,
+  codeVerifier,
+  redirectUri,
+}: KakaoCodeTokenOptions): Promise<KakaoLoginToken> {
+  kAssert(is.string(code) && code.length > 0, '[issueAccessTokenWithCode] code is required');
+
+  return Native.issueAccessTokenWithCode(code, codeVerifier, redirectUri);
 }
 
 export function getAccessToken(): Promise<KakaoAccessTokenInfo> {
   return Native.getAccessToken();
 }
 
+export async function updateProfile({
+  properties,
+}: {
+  properties: Record<string, string>;
+}): Promise<void> {
+  await Native.updateProfile(properties);
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function setAccessTokenWeb(token: string) {}
+export function setAccessTokenWeb(token: string): void {
+  kCreateWebError({
+    code: webOnlyErrorCode,
+    message: '[setAccessTokenWeb] This API is only supported on web.',
+  });
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function issueAccessTokenWithCodeWeb(params: {
   redirectUri: string;
   clientSecret?: string;
   code: string;
+  codeVerifier?: string;
 }): Promise<{
   tokenType: string;
   accessToken: string;
@@ -219,11 +388,18 @@ export async function issueAccessTokenWithCodeWeb(params: {
   refreshTokenExpiresIn: number;
   scope?: string;
 }> {
-  return {} as any;
+  kCreateWebError({
+    code: webOnlyErrorCode,
+    message: '[issueAccessTokenWithCodeWeb] This API is only supported on web.',
+  });
 }
 
 const KakaoUser = {
   login,
+  loginWithKakao,
+  refreshToken,
+  issueAccessTokenWithCode,
+  signup,
   logout,
   unlink,
   isLogined,
@@ -231,11 +407,13 @@ const KakaoUser = {
   isKakaoTalkLoginAvailable,
   scopes,
   revokeScopes,
+  revokeScopesWithResult,
   serviceTerms,
   revokeServiceTerms,
   shippingAddresses,
   selectShippingAddress,
   me,
+  updateProfile,
   getAccessToken,
   setAccessTokenWeb,
   issueAccessTokenWithCodeWeb,

package/src/index.web.ts

@@ -1,9 +1,17 @@
 import { camelCaseObject, filterNonNullishKeys, is } from '@mj-studio/js-util';
-import { kFetch, kFetchFormUrlEncoded, kGlobalStorage, kRunWebAPI } from '@react-native-kakao/core';
+import {
+  kAssert,
+  kCreateWebError,
+  kFetch,
+  kFetchFormUrlEncoded,
+  kGlobalStorage,
+  kRunWebAPI,
+} from '@react-native-kakao/core';
 
 import {
   type KakaoLoginToken,
   type KakaoScopeInfo,
+  type KakaoServiceTerms,
   type KakaoShippingAddressResult,
   type KakaoUser as KakaoUserProfile,
   type KakaoUserAPI,
@@ -11,6 +19,7 @@ import {
 import { validateShippingAddressOptions } from './validateShippingAddressOptions';
 
 declare const Kakao: {
+  isInitialized: () => boolean;
   Auth: {
     authorize: Function;
     logout: Function;
@@ -30,6 +39,21 @@ function isoToUnix(value?: string | number) {
 }
 
 const KakaoUser: KakaoUserAPI = {
+  loginWithKakao: () =>
+    kRunWebAPI(() => {
+      throw {
+        code: 'Package-UnsupportedPlatform',
+        message:
+          'loginWithKakao is supported on Android and iOS. Use login with web.redirectUri on web.',
+      };
+    }),
+  refreshToken: () =>
+    kRunWebAPI(() => {
+      throw {
+        code: 'Package-UnsupportedPlatform',
+        message: 'The Kakao JavaScript SDK does not support refreshToken.',
+      };
+    }),
   hasToken: () => kRunWebAPI(() => Kakao.Auth.getAccessToken() != null),
   getAccessToken: () =>
     kRunWebAPI(async () => {
@@ -42,7 +66,62 @@ const KakaoUser: KakaoUserAPI = {
         appId: app_id,
       };
     }),
-  issueAccessTokenWithCodeWeb: ({ clientSecret, code, redirectUri }) =>
+  issueAccessTokenWithCode: ({ code, codeVerifier, redirectUri, web }) =>
+    kRunWebAPI(async () => {
+      kAssert(
+        is.string(code) && code.length > 0 && is.string(redirectUri) && redirectUri.length > 0,
+        '[issueAccessTokenWithCode] code and redirectUri are required on web',
+      );
+
+      if (typeof Kakao === 'undefined' || !Kakao.isInitialized()) {
+        kCreateWebError({
+          code: 'Package-SDKNotInitialized',
+          message: 'Initialize the Kakao SDK before exchanging an authorization code.',
+        });
+      }
+
+      const token = await KakaoUser.issueAccessTokenWithCodeWeb({
+        code,
+        codeVerifier,
+        redirectUri: redirectUri!,
+        clientSecret: web?.clientSecret,
+      });
+
+      if (
+        !is.string(token.accessToken) ||
+        !token.accessToken ||
+        !is.string(token.refreshToken) ||
+        !token.refreshToken ||
+        !is.string(token.tokenType) ||
+        (token.idToken != null && !is.string(token.idToken)) ||
+        !Number.isFinite(token.expiresIn) ||
+        token.expiresIn < 0 ||
+        !Number.isFinite(token.refreshTokenExpiresIn) ||
+        token.refreshTokenExpiresIn < 0 ||
+        (token.scope != null && !is.string(token.scope))
+      ) {
+        kCreateWebError({
+          code: 'Package-APIResponseNotFound',
+          message: 'issueAccessTokenWithCode returned invalid token data.',
+        });
+      }
+
+      const issuedAt = Math.floor(Date.now() / 1000);
+      KakaoUser.setAccessTokenWeb(token.accessToken);
+
+      return {
+        accessToken: token.accessToken,
+        refreshToken: token.refreshToken,
+        tokenType: token.tokenType,
+        idToken: token.idToken,
+        accessTokenExpiresIn: token.expiresIn,
+        refreshTokenExpiresIn: token.refreshTokenExpiresIn,
+        accessTokenExpiresAt: issuedAt + token.expiresIn,
+        refreshTokenExpiresAt: issuedAt + token.refreshTokenExpiresIn,
+        scopes: token.scope?.split(' ').filter(Boolean) ?? [],
+      };
+    }),
+  issueAccessTokenWithCodeWeb: ({ clientSecret, code, codeVerifier, redirectUri }) =>
     kRunWebAPI(async () => {
       const res = await kFetchFormUrlEncoded<{
         token_type: string;
@@ -59,6 +138,7 @@ const KakaoUser: KakaoUserAPI = {
           client_id: kGlobalStorage.restApiKey,
           redirect_uri: redirectUri,
           code,
+          code_verifier: codeVerifier,
           client_secret: clientSecret,
         }),
       }).then((r) => r.body);
@@ -73,10 +153,12 @@ const KakaoUser: KakaoUserAPI = {
     kRunWebAPI(() => {
       const { loginHint, nonce, prompt, redirectUri, scope, state, throughTalk, serviceTerms } =
         params?.web ?? {};
+      const channelPublicIds = params?.channelPublicIds;
 
       return Kakao.Auth.authorize(
         filterNonNullishKeys({
-          loginHint,
+          loginHint: params?.loginHint ?? loginHint,
+          channelPublicId: channelPublicIds?.length ? channelPublicIds.join(',') : undefined,
           nonce: params?.nonce ?? nonce,
           prompt: (
             prompt ??
@@ -92,6 +174,13 @@ const KakaoUser: KakaoUserAPI = {
         }),
       );
     }),
+  signup: ({ properties } = {}) =>
+    kRunWebAPI(async () => {
+      await Kakao.API.request({
+        url: '/v1/user/signup',
+        data: filterNonNullishKeys({ properties }),
+      });
+    }),
   logout: () =>
     kRunWebAPI(async () => {
       try {
@@ -123,17 +212,12 @@ const KakaoUser: KakaoUserAPI = {
         data: scopes?.length ? { scopes } : undefined,
       });
 
-      return camelCaseObject(response.scopes) as KakaoScopeInfo[];
-    }),
-  revokeScopes: (scopes: string[]) =>
-    kRunWebAPI(async () => {
-      await Kakao.API.request({
-        url: '/v2/user/revoke/scopes',
-        data: {
-          scopes,
-        },
-      });
+      return camelCaseObject(response.scopes ?? []) as KakaoScopeInfo[];
     }),
+  revokeScopes: async (scopes: string[]) => {
+    await revokeScopesWithResult(scopes);
+  },
+  revokeScopesWithResult,
   serviceTerms: ({ result, tags } = {}) =>
     kRunWebAPI(async () => {
       const response: {
@@ -144,6 +228,7 @@ const KakaoUser: KakaoUserAPI = {
               agreed: boolean;
               required: boolean;
               revocable: boolean;
+              agreed_by?: string | null;
             }[]
           | null;
       } = await Kakao.API.request({
@@ -151,13 +236,22 @@ const KakaoUser: KakaoUserAPI = {
         data: filterNonNullishKeys({ result, tags: tags?.join(',') }),
       });
 
-      return (response.service_terms ?? []).map((term) => ({
-        tag: term.tag,
-        agreedAt: term.agreed_at ? isoToUnix(term.agreed_at) : undefined,
-        agreed: term.agreed,
-        required: term.required,
-        revocable: term.revocable,
-      }));
+      return (response.service_terms ?? []).map(
+        (term): KakaoServiceTerms =>
+          filterNonNullishKeys({
+            tag: term.tag,
+            agreedAt: term.agreed_at ? isoToUnix(term.agreed_at) : undefined,
+            agreed: term.agreed,
+            required: term.required,
+            revocable: term.revocable,
+            agreedBy:
+              term.agreed_by == null
+                ? undefined
+                : term.agreed_by === 'KAUTH' || term.agreed_by === 'KAPI'
+                  ? term.agreed_by
+                  : 'unknown',
+          }),
+      );
     }),
   revokeServiceTerms: (tags) =>
     kRunWebAPI(async () => {
@@ -226,15 +320,33 @@ const KakaoUser: KakaoUserAPI = {
         throw error;
       }
     }),
-  me: () =>
+  updateProfile: ({ properties }) =>
     kRunWebAPI(async () => {
-      const ret = camelCaseObject(await Kakao.API.request({ url: '/v2/user/me' })) as {
+      await Kakao.API.request({ url: '/v1/user/update_profile', data: { properties } });
+    }),
+  me: ({ propertyKeys, secureResource = true } = {}) =>
+    kRunWebAPI(async () => {
+      const response: { properties?: Record<string, string> } = await Kakao.API.request({
+        url: '/v2/user/me',
+        data: filterNonNullishKeys({
+          property_keys: propertyKeys,
+          secure_resource: secureResource,
+        }),
+      });
+
+      const ret = camelCaseObject(response) as {
         id: number;
+        hasSignedUp?: boolean | null;
+        forPartner?: { uuid?: string };
+        groupUserToken?: string;
         connectedAt?: string;
         synchedAt?: string;
         kakaoAccount?: Partial<KakaoUserProfile> & {
           profile?: Partial<
-            Pick<KakaoUserProfile, 'nickname' | 'profileImageUrl' | 'thumbnailImageUrl'>
+            Pick<
+              KakaoUserProfile,
+              'nickname' | 'profileImageUrl' | 'thumbnailImageUrl' | 'isDefaultImage'
+            >
           >;
         };
         properties?: { nickname?: string; profileImage?: string; thumbnailImage?: string };
@@ -242,9 +354,22 @@ const KakaoUser: KakaoUserAPI = {
       const kakaoAccount = ret.kakaoAccount ?? {};
       const properties = ret.properties ?? {};
       const profile = kakaoAccount.profile ?? {};
+      const legalGender = kakaoAccount.legalGender;
 
       return {
         id: ret.id,
+        properties: response.properties ?? {},
+        hasSignedUp: ret.hasSignedUp ?? null,
+        uuid: ret.forPartner?.uuid ?? null,
+        groupUserToken: ret.groupUserToken ?? null,
+        isDefaultImage: profile.isDefaultImage ?? null,
+        isLeapMonth: kakaoAccount.isLeapMonth ?? null,
+        legalName: kakaoAccount.legalName ?? null,
+        legalNameNeedsAgreement: kakaoAccount.legalNameNeedsAgreement ?? null,
+        legalBirthDate: kakaoAccount.legalBirthDate ?? null,
+        legalBirthDateNeedsAgreement: kakaoAccount.legalBirthDateNeedsAgreement,
+        legalGender: legalGender === 'female' || legalGender === 'male' ? legalGender : null,
+        legalGenderNeedsAgreement: kakaoAccount.legalGenderNeedsAgreement ?? null,
         email: kakaoAccount.email,
         name: kakaoAccount.name,
         nickname: profile.nickname ?? properties.nickname,
@@ -270,20 +395,35 @@ const KakaoUser: KakaoUserAPI = {
         nameNeedsAgreement: kakaoAccount.nameNeedsAgreement,
         profileImageNeedsAgreement: kakaoAccount.profileImageNeedsAgreement,
         profileNicknameNeedsAgreement: kakaoAccount.profileNicknameNeedsAgreement,
-        legalBirthDateNeedsAgreement: kakaoAccount.legalBirthDateNeedsAgreement,
         connectedAt: isoToUnix(ret.connectedAt),
         synchedAt: isoToUnix(ret.synchedAt),
       } as KakaoUserProfile;
     }),
 };
 
+export function revokeScopesWithResult(scopes: string[]): Promise<KakaoScopeInfo[]> {
+  return kRunWebAPI(async () => {
+    const response = await Kakao.API.request({
+      url: '/v2/user/revoke/scopes',
+      data: { scopes },
+    });
+
+    return camelCaseObject(response.scopes ?? []) as KakaoScopeInfo[];
+  });
+}
+
 export const {
+  loginWithKakao,
+  refreshToken,
+  issueAccessTokenWithCode,
   isKakaoTalkLoginAvailable,
   isLogined,
   hasToken,
   login,
+  signup,
   logout,
   me,
+  updateProfile,
   revokeScopes,
   scopes,
   serviceTerms,