### Check Universal Link Readiness (iOS)

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Verifies the Universal Link setup for iOS, crucial for debugging authentication and deep linking. Logs suggestions or errors.

```typescript
import { checkUniversalLinkReady } from 'native-wechat';

async function verifyUniversalLinkSetup() {
  try {
    const result = await checkUniversalLinkReady();

    if (result.suggestion) {
      console.warn('Universal Link suggestion:', result.suggestion);
    }

    if (result.errorInfo) {
      console.error('Universal Link error:', result.errorInfo);
    } else {
      console.log('Universal Link is configured correctly');
    }

    return result;
  } catch (error) {
    console.error('Failed to check Universal Link:', error);
  }
}
```

--------------------------------

### Check WeChat Installation

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Checks if the WeChat app is installed on the device.

```APIDOC
## isWechatInstalled

### Description
Checks whether the WeChat app is installed on the user's device. Returns a promise that resolves to a boolean indicating WeChat installation status.

### Method
`isWechatInstalled`

### Endpoint
N/A (Function call)

### Response
#### Success Response (Promise<boolean>)
- **Resolves to true** if WeChat is installed.
- **Resolves to false** if WeChat is not installed.

#### Response Example
```json
true
```
```

```APIDOC
## useWechatInstalled Hook

### Description
A React hook that returns a boolean state indicating whether WeChat is installed. Automatically checks installation status on mount.

### Hook
`useWechatInstalled`

### Response
#### Success Response (boolean)
- **Returns true** if WeChat is installed.
- **Returns false** if WeChat is not installed.

#### Response Example
```json
true
```
```

--------------------------------

### React Hook for WeChat Installation Status

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

The useWechatInstalled hook provides a reactive boolean state for WeChat installation. It automatically checks the status when the component mounts.

```typescript
import { useWechatInstalled } from 'native-wechat';
import { View, Button, Text } from 'react-native';

function LoginScreen() {
  const hasWechatInstalled = useWechatInstalled();

  return (
    <View>
      {hasWechatInstalled ? (
        <Button title="Login with WeChat" onPress={handleWechatLogin} />
      ) : (
        <Text>WeChat is not installed. Please use another login method.</Text>
      )}
    </View>
  );
}
```

--------------------------------

### Check WeChat Installation Status

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Use isWechatInstalled to determine if the WeChat app is available on the device. This is crucial for conditionally enabling WeChat-specific features.

```typescript
import { isWechatInstalled } from 'native-wechat';

async function checkWechatAvailability() {
  try {
    const isInstalled = await isWechatInstalled();

    if (isInstalled) {
      console.log('WeChat is installed, enabling WeChat features');
    } else {
      console.log('WeChat is not installed, showing alternative login');
    }

    return isInstalled;
  } catch (error) {
    console.error('Failed to check WeChat installation:', error);
    return false;
  }
}
```

--------------------------------

### Share WeChat Mini Program

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Shares a WeChat Mini Program to a chat session. Includes a fallback webpage URL for users who don't have the mini program installed.

```typescript
import { shareMiniProgram, NativeWechatConstants } from 'native-wechat';

// Mini Program types from NativeWechatConstants:
// - WXMiniProgramTypeRelease: Production version (0)
// - WXMiniProgramTypeTest: Development version (1)
// - WXMiniProgramTypePreview: Preview version (2)

async function shareMiniProgramCard() {
  try {
    await shareMiniProgram({
      userName: 'gh_abcdef123456', // Mini Program original ID (starts with gh_)
      path: '/pages/product/detail?id=12345', // Page path with query params
      miniProgramType: NativeWechatConstants.WXMiniProgramTypeRelease,
      webpageUrl: 'https://yourwebsite.com/product/12345', // Fallback URL
      withShareTicket: true, // Enable share ticket for group sharing
      title: 'Amazing Product',
      description: 'Check out this product in our mini program!',
      coverUrl: 'https://example.com/miniprogram-cover.jpg',
      scene: NativeWechatConstants.WXSceneSession
    });
    console.log('Mini program shared successfully');
  } catch (error) {
    console.error('Failed to share mini program:', error);
  }
}
```

--------------------------------

### Complete WeChat Integration in React Native

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This snippet shows a full integration of Native WeChat, including app registration, user authentication via OAuth, content sharing, and payment processing. It uses React hooks for managing WeChat installation status and login state. Ensure the app is registered with WeChat and backend endpoints are correctly configured.

```typescript
import React, { useEffect, useState } from 'react';
import { View, Button, Alert, StyleSheet } from 'react-native';
import {
  registerApp,
  sendAuthRequest,
  shareWebpage,
  requestPayment,
  isWechatInstalled,
  useWechatInstalled,
  NativeWechatConstants
} from 'native-wechat';

function WechatIntegrationExample() {
  const hasWechat = useWechatInstalled();
  const [isLoggedIn, setIsLoggedIn] = useState(false);

  useEffect(() => {
    // Initialize WeChat SDK on app mount
    const cleanup = registerApp({
      appid: 'wx964290141ebe9b7b',
      universalLink: 'https://yourapp.com/app/',
      log: __DEV__
    });

    return cleanup;
  }, []);

  const handleLogin = async () => {
    try {
      const response = await sendAuthRequest({
        scope: 'snsapi_userinfo',
        state: `login_${Date.now()}`
      });

      // Exchange code for token on your backend
      const authResult = await fetch('https://api.yourapp.com/auth/wechat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ code: response.data.code })
      });

      if (authResult.ok) {
        setIsLoggedIn(true);
        Alert.alert('Success', 'Logged in with WeChat!');
      }
    } catch (error) {
      Alert.alert('Error', `Login failed: ${error.message}`);
    }
  };

  const handleShare = async () => {
    try {
      await shareWebpage({
        title: 'Check out our app!',
        description: 'The best React Native app powered by Native Wechat',
        webpageUrl: 'https://yourapp.com',
        coverUrl: 'https://yourapp.com/share-image.png',
        scene: NativeWechatConstants.WXSceneSession
      });
      Alert.alert('Shared', 'Content shared successfully!');
    } catch (error) {
      Alert.alert('Error', `Share failed: ${error.message}`);
    }
  };

  const handlePayment = async () => {
    try {
      // Get payment params from your backend
      const params = await fetch('https://api.yourapp.com/payment/create', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ amount: 100, description: 'Test Payment' })
      }).then(res => res.json());

      const result = await requestPayment(params);

      if (result.errorCode === 0) {
        Alert.alert('Success', 'Payment completed!');
      }
    } catch (error) {
      Alert.alert('Error', `Payment failed: ${error.message}`);
    }
  };

  if (!hasWechat) {
    return (
      <View style={styles.container}>
        <Button title="WeChat not installed" disabled />
      </View>
    );
  }

  return (
    <View style={styles.container}>
      {!isLoggedIn ? (
        <Button title="Login with WeChat" onPress={handleLogin} />
      ) : (
        <>
          <Button title="Share to WeChat" onPress={handleShare} />
          <View style={styles.spacer} />
          <Button title="WeChat Pay" onPress={handlePayment} />
        </>
      )}
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, justifyContent: 'center', padding: 20 },
  spacer: { height: 16 }
});

export default WechatIntegrationExample;

```

--------------------------------

### Launch Mini Program

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Opens a WeChat Mini Program directly and can receive data upon returning.

```APIDOC
## POST /launchMiniProgram

### Description
Opens a WeChat Mini Program directly from your React Native app. Optionally receives data when the user navigates back from the mini program.

### Method
POST

### Endpoint
/launchMiniProgram

### Parameters
#### Request Body
- **userName** (string) - Required - Mini Program original ID
- **path** (string) - Required - Target page path
- **miniprogramType** (number) - Required - Mini Program type (0: Release, 1: Test, 2: Preview)
- **onNavBack** (function) - Optional - Callback function executed when the user returns from the mini program. Receives a response object containing data passed back.

### Request Example
{
  "userName": "gh_abcdef123456",
  "path": "/pages/index/index?source=app",
  "miniprogramType": 0,
  "onNavBack": (response) => {
    console.log('Returned from mini program');
    if (response.data?.extMsg) {
      const returnedData = JSON.parse(response.data.extMsg);
      console.log('Data from mini program:', returnedData);
    }
  }
}

### Response
#### Success Response (200)
- **message** (string) - Indicates successful launch.

#### Response Example
{
  "message": "Mini program launched"
}
```

--------------------------------

### Check Universal Link Ready

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Verifies the correctness of Universal Link configuration, specifically for iOS, aiding in the debugging of authentication and deep linking issues.

```APIDOC
## GET /checkUniversalLinkReady

### Description
Checks if the Universal Link configuration is correct (iOS only). Useful for debugging authentication and deep linking issues.

### Method
GET

### Endpoint
/checkUniversalLinkReady

### Parameters
This endpoint does not require any parameters.

### Request Example
```json
// No request body or parameters needed for this endpoint.
```

### Response
#### Success Response (200)
- **suggestion** (string) - Optional - Provides a suggestion for improving the Universal Link setup.
- **errorInfo** (string) - Optional - Detailed information about any errors encountered during the check.

#### Response Example
```json
{
  "suggestion": "Ensure your Associated Domains are correctly configured in Xcode.",
  "errorInfo": null
}
```

```json
{
  "suggestion": null,
  "errorInfo": "Failed to verify Universal Link: Missing apple-app-site-association file."
}
```
```

--------------------------------

### Share Mini Program

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Allows sharing a WeChat Mini Program to a chat session, with an option for a fallback webpage.

```APIDOC
## POST /shareMiniProgram

### Description
Shares a WeChat Mini Program to a chat session. Includes a fallback webpage URL for users who don't have the mini program installed.

### Method
POST

### Endpoint
/shareMiniProgram

### Parameters
#### Request Body
- **userName** (string) - Required - Mini Program original ID (starts with gh_)
- **path** (string) - Required - Page path with query params
- **miniProgramType** (number) - Required - Mini Program type (0: Release, 1: Test, 2: Preview)
- **webpageUrl** (string) - Required - Fallback URL
- **withShareTicket** (boolean) - Optional - Enable share ticket for group sharing
- **title** (string) - Required - Title of the shared mini program card
- **description** (string) - Required - Description of the shared mini program card
- **coverUrl** (string) - Required - URL of the cover image
- **scene** (number) - Required - Scene to share to (e.g., WXSceneSession)

### Request Example
{
  "userName": "gh_abcdef123456",
  "path": "/pages/product/detail?id=12345",
  "miniProgramType": 0,
  "webpageUrl": "https://yourwebsite.com/product/12345",
  "withShareTicket": true,
  "title": "Amazing Product",
  "description": "Check out this product in our mini program!",
  "coverUrl": "https://example.com/miniprogram-cover.jpg",
  "scene": 0
}

### Response
#### Success Response (200)
- **message** (string) - Indicates successful sharing.

#### Response Example
{
  "message": "Mini program shared successfully"
}
```

--------------------------------

### Share Product Webpage to WeChat Moments

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This function shares a product webpage to WeChat Moments, dynamically setting the title, description, URL, and image from a product object. Ensure 'shareWebpage' and 'NativeWechatConstants' are imported.

```typescript
import { shareWebpage, NativeWechatConstants } from 'native-wechat';

async function shareProductToMoments(product: { name: string; url: string; image: string }) {
  try {
    await shareWebpage({
      title: product.name,
      description: 'Check out this product!',
      webpageUrl: product.url,
      coverUrl: product.image,
      scene: NativeWechatConstants.WXSceneTimeline
    });
  } catch (error) {
    console.error('Failed to share product:', error);
  }
}
```

--------------------------------

### Launch WeChat Mini Program

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Opens a WeChat Mini Program directly from your React Native app. Optionally receives data when the user navigates back from the mini program.

```typescript
import { launchMiniProgram, NativeWechatConstants } from 'native-wechat';

async function openMiniProgram() {
  try {
    await launchMiniProgram({
      userName: 'gh_abcdef123456', // Mini Program original ID
      path: '/pages/index/index?source=app', // Target page path
      miniprogramType: NativeWechatConstants.WXMiniProgramTypeRelease,
      onNavBack: (response) => {
        // Called when user returns from mini program
        console.log('Returned from mini program');

        if (response.data?.extMsg) {
          // Mini program can pass data back via extMsg
          const returnedData = JSON.parse(response.data.extMsg);
          console.log('Data from mini program:', returnedData);
        }
      }
    });
    console.log('Mini program launched');
  } catch (error) {
    console.error('Failed to launch mini program:', error);
  }
}
```

--------------------------------

### Send Authentication Request

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Initiates an OAuth authentication flow with WeChat.

```APIDOC
## sendAuthRequest

### Description
Sends an OAuth authentication request to WeChat. The user will be redirected to WeChat to authorize your app. Returns a promise that resolves with the authorization code when the user completes authentication.

### Method
`sendAuthRequest`

### Parameters
#### Request Body
- **scope** (string) - Required - The scope of the request (e.g., 'snsapi_userinfo').
- **state** (string) - Optional - A string for security verification to prevent cross-site request forgery.

### Request Example
```json
{
  "scope": "snsapi_userinfo",
  "state": "random_state_string"
}
```

### Response
#### Success Response (Promise<NativeWechatResponse>)
- **type** (string) - 'SendAuthResp'
- **errorCode** (number) - 0 for success.
- **errorStr** (string | null) - Error message if any.
- **data** (object) - Contains authentication details:
  - **code** (string) - The authorization code.
  - **country** (string) - The country code.
  - **lang** (string) - The language code.
  - **state** (string) - The state string provided in the request.

#### Response Example
```json
{
  "type": "SendAuthResp",
  "errorCode": 0,
  "errorStr": null,
  "data": {
    "code": "authorization_code_here",
    "country": "CN",
    "lang": "zh_CN",
    "state": "custom_state"
  }
}
```
```

--------------------------------

### Native WeChat Constants for Scenes and Mini Programs

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Provides constants for WeChat scene types (session, timeline, favorite) and mini-program types (release, test, preview). Use these with sharing and mini-program APIs.

```typescript
import { NativeWechatConstants } from 'native-wechat';

// Share scene constants
const scenes = {
  // Share to a chat session (individual or group)
  session: NativeWechatConstants.WXSceneSession, // 0

  // Share to WeChat Moments (Timeline)
  timeline: NativeWechatConstants.WXSceneTimeline, // 1

  // Add to Favorites
  favorite: NativeWechatConstants.WXSceneFavorite // 2
};

// Mini Program type constants
const miniProgramTypes = {
  // Production/Release version
  release: NativeWechatConstants.WXMiniProgramTypeRelease, // 0

  // Development/Test version
  test: NativeWechatConstants.WXMiniProgramTypeTest, // 1

  // Preview version
  preview: NativeWechatConstants.WXMiniProgramTypePreview // 2
};

// Usage example
async function shareBasedOnUserChoice(content: string, targetScene: 'chat' | 'moments' | 'favorite') {
  const sceneMap = {
    chat: NativeWechatConstants.WXSceneSession,
    moments: NativeWechatConstants.WXSceneTimeline,
    favorite: NativeWechatConstants.WXSceneFavorite
  };

  await shareText({ // Assuming shareText is defined elsewhere
    text: content,
    scene: sceneMap[targetScene]
  });
}
```

--------------------------------

### NativeWechatConstants

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Provides constant values for WeChat scene types and mini program types, essential for sharing functionalities and mini program interactions.

```APIDOC
## Constants Reference

### Description
Provides constant values for WeChat scene types and mini program types. These constants should be used with sharing and mini program APIs.

### Constants
#### Share Scene Constants
- **WXSceneSession** (number): 0 - Share to a chat session (individual or group).
- **WXSceneTimeline** (number): 1 - Share to WeChat Moments (Timeline).
- **WXSceneFavorite** (number): 2 - Add to Favorites.

#### Mini Program Type Constants
- **WXMiniProgramTypeRelease** (number): 0 - Production/Release version.
- **WXMiniProgramTypeTest** (number): 1 - Development/Test version.
- **WXMiniProgramTypePreview** (number): 2 - Preview version.

### Usage Example
```typescript
import { NativeWechatConstants } from 'native-wechat';

// Share to a chat session
const scene = NativeWechatConstants.WXSceneSession; // 0

// Use the release version of a mini program
const miniProgramType = NativeWechatConstants.WXMiniProgramTypeRelease; // 0
```
```

--------------------------------

### Request Payment

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Initiates a WeChat Pay payment request using parameters generated by a backend server.

```APIDOC
## POST /requestPayment

### Description
Initiates a WeChat Pay payment request. The payment parameters must be generated by your backend server using WeChat's payment API.

### Method
POST

### Endpoint
/requestPayment

### Parameters
#### Request Body
- **partnerId** (string) - Required - Merchant ID
- **prepayId** (string) - Required - Prepay ID from WeChat
- **nonceStr** (string) - Required - Random string
- **timeStamp** (string) - Required - Unix timestamp as string
- **sign** (string) - Required - Signature generated by the backend

### Request Example
{
  "partnerId": "1900000109",
  "prepayId": "1900000109202301011234567890",
  "nonceStr": "5K8264IL90VO0800",
  "timeStamp": "1494213727",
  "sign": "0CB015720A87734744A007F0C2000000"
}

### Response
#### Success Response (200)
- **type** (string) - Type of response, expected to be 'PayResp'.
- **errorCode** (number) - Error code, 0 indicates success.
- **errorStr** (string|null) - Error message if any.
- **data** (object) - Additional data, usually empty on success.

#### Response Example
{
  "type": "PayResp",
  "errorCode": 0,
  "errorStr": null,
  "data": {}
}
```

--------------------------------

### Register App

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Registers your application with the WeChat SDK. This must be called before invoking any other WeChat APIs.

```APIDOC
## registerApp

### Description
Registers your application with the WeChat SDK. This must be called before invoking any other WeChat APIs. The function sets up an event listener to receive responses from WeChat and returns a cleanup function to remove the listener.

### Method
`registerApp`

### Parameters
#### Request Body
- **appid** (string) - Required - Your WeChat application ID.
- **universalLink** (string) - Required (iOS only) - The universal link for your iOS application.
- **log** (boolean) - Optional - Enable logging for debugging.
- **logPrefix** (string) - Optional - Custom prefix for log messages.

### Request Example
```json
{
  "appid": "wx964290141ebe9b7b",
  "universalLink": "https://yourapp.com/app/",
  "log": true,
  "logPrefix": "[WeChat]"
}
```

### Response
Returns a cleanup function to remove the event listener.
```

--------------------------------

### Share Webpage to WeChat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This endpoint facilitates sharing of webpage links to WeChat. It includes options for title, description, and a cover image, making it suitable for sharing articles, products, or any web content.

```APIDOC
## POST /shareWebpage

### Description
Shares a webpage URL to WeChat with title, description, and optional cover image. Ideal for sharing articles, products, or web content.

### Method
POST

### Endpoint
/shareWebpage

### Parameters
#### Request Body
- **title** (string) - Required - The title of the webpage.
- **description** (string) - Required - The description of the webpage.
- **webpageUrl** (string) - Required - The URL of the webpage.
- **coverUrl** (string) - Optional - The URL of the cover image for the webpage.
- **scene** (string) - Required - The scene to share to. Possible values: WXSceneSession, WXSceneTimeline, WXSceneFavorite.

### Request Example
```json
{
  "title": "Introduction to React Native",
  "description": "Learn how to build mobile apps with React Native framework",
  "webpageUrl": "https://reactnative.dev/docs/getting-started",
  "coverUrl": "https://reactnative.dev/img/header_logo.svg",
  "scene": "WXSceneSession"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful sharing.

#### Response Example
```json
{
  "message": "Webpage shared successfully"
}
```
```

--------------------------------

### Share Video to WeChat Chat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Shares a video to a WeChat chat session, with options for title, description, video URLs (high/low bandwidth), and a cover image. Import 'shareVideo' and 'NativeWechatConstants'.

```typescript
import { shareVideo, NativeWechatConstants } from 'native-wechat';

async function shareVideoContent() {
  try {
    await shareVideo({
      title: 'My Awesome Video',
      description: 'Check out this cool video I made!',
      videoUrl: 'https://example.com/videos/main.mp4',
      videoLowBandUrl: 'https://example.com/videos/main-low.mp4', // Optional: for slow connections
      coverUrl: 'https://example.com/videos/thumbnail.jpg', // Optional: video thumbnail
      scene: NativeWechatConstants.WXSceneSession
    });
    console.log('Video shared successfully');
  } catch (error) {
    console.error('Failed to share video:', error);
  }
}
```

--------------------------------

### Share Local Image to WeChat Moments

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This function shares a local image file to WeChat Moments. Ensure the 'src' path is correctly formatted.

```typescript
import { shareImage, NativeWechatConstants } from 'native-wechat';

async function shareLocalImage() {
  try {
    // Share from local file path
    await shareImage({
      src: 'file:///path/to/local/image.png',
      scene: NativeWechatConstants.WXSceneTimeline
    });
  } catch (error) {
    console.error('Failed to share local image:', error);
  }
}
```

--------------------------------

### Open Customer Service

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Opens the WeChat customer service interface for seamless integration with enterprise customer support systems.

```APIDOC
## POST /openCustomerService

### Description
Opens WeChat's customer service chat interface for enterprise customer support integration.

### Method
POST

### Endpoint
/openCustomerService

### Parameters
#### Request Body
- **corpid** (string) - Required - Enterprise WeChat Corp ID.
- **url** (string) - Required - Customer service URL from WeChat Work.

### Request Example
```json
{
  "corpid": "ww1234567890abcdef",
  "url": "https://work.weixin.qq.com/kfid/xxxxx"
}
```

### Response
#### Success Response (200)
This API does not explicitly define a success response body in the provided documentation. Typically, a successful operation would indicate the chat interface has been opened.

#### Response Example
```json
// No specific success response body defined in documentation.
// A successful call would typically result in the UI transition to the chat.
```
```

--------------------------------

### Register WeChat App

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Call registerApp before any other WeChat APIs. It sets up an event listener and returns a cleanup function. Ensure this is called during app initialization.

```typescript
import { registerApp } from 'native-wechat';
import { useEffect } from 'react';

function App() {
  useEffect(() => {
    // Register with WeChat SDK - returns cleanup function
    const unsubscribe = registerApp({
      appid: 'wx964290141ebe9b7b',
      universalLink: 'https://yourapp.com/app/', // iOS only - required for iOS
      log: true, // Optional: enable logging
      logPrefix: '[WeChat]'
    });

    // Cleanup listener on unmount
    return unsubscribe;
  }, []);

  return <YourApp />;
}
```

--------------------------------

### Share Webpage to WeChat Chat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Shares a webpage URL to a WeChat chat session, including title, description, and an optional cover image. Requires importing 'shareWebpage' and 'NativeWechatConstants'.

```typescript
import { shareWebpage, NativeWechatConstants } from 'native-wechat';

async function shareArticle() {
  try {
    await shareWebpage({
      title: 'Introduction to React Native',
      description: 'Learn how to build mobile apps with React Native framework',
      webpageUrl: 'https://reactnative.dev/docs/getting-started',
      coverUrl: 'https://reactnative.dev/img/header_logo.svg',
      scene: NativeWechatConstants.WXSceneSession
    });
    console.log('Webpage shared successfully');
  } catch (error) {
    console.error('Failed to share webpage:', error);
  }
}
```

--------------------------------

### Open WeChat Customer Service

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Initiates a chat with enterprise customer support. Requires the enterprise Corp ID and a customer service URL.

```typescript
import { openCustomerService } from 'native-wechat';

async function contactSupport() {
  try {
    await openCustomerService({
      corpid: 'ww1234567890abcdef', // Enterprise WeChat Corp ID
      url: 'https://work.weixin.qq.com/kfid/xxxxx' // Customer service URL from WeChat Work
    });
    console.log('Customer service chat opened');
  } catch (error) {
    console.error('Failed to open customer service:', error);
  }
}
```

--------------------------------

### Register WeChat SDK

Source: https://github.com/hector-zhuang/native-wechat/blob/main/readme.md

Essential step before invoking any WeChat APIs. This function registers the app with WeChat and returns a function to remove the associated event listener.

```typescript
import {registerApp} from 'native-wechat';

useEffect(()=>{
	return registerApp('wx964290141ebe9b7b');
}, [])
```

--------------------------------

### Share Image to WeChat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This endpoint enables sharing of image content to WeChat. It supports images from both local file paths and remote URLs. The SDK handles image downloading and thumbnail generation.

```APIDOC
## POST /shareImage

### Description
Shares an image to WeChat. Supports both local file paths and remote URLs. The image is automatically downloaded and compressed for thumbnail generation.

### Method
POST

### Endpoint
/shareImage

### Parameters
#### Request Body
- **src** (string) - Required - The source of the image. Can be a local file path (e.g., 'file:///path/to/image.png') or a remote URL (e.g., 'https://example.com/image.jpg').
- **scene** (string) - Required - The scene to share to. Possible values: WXSceneSession, WXSceneTimeline, WXSceneFavorite.

### Request Example
```json
{
  "src": "https://example.com/images/photo.jpg",
  "scene": "WXSceneSession"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful sharing.

#### Response Example
```json
{
  "message": "Image shared successfully"
}
```
```

--------------------------------

### Share Video to WeChat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This endpoint allows sharing video content to WeChat. You can include a title, description, and cover image for the shared video. It supports both high-bandwidth and low-bandwidth video URLs.

```APIDOC
## POST /shareVideo

### Description
Shares a video to WeChat with optional title, description, and cover image. Supports both high-bandwidth and low-bandwidth video URLs.

### Method
POST

### Endpoint
/shareVideo

### Parameters
#### Request Body
- **title** (string) - Optional - The title of the video.
- **description** (string) - Optional - The description of the video.
- **videoUrl** (string) - Required - The URL of the video.
- **videoLowBandUrl** (string) - Optional - The URL for low-bandwidth connections.
- **coverUrl** (string) - Optional - The URL of the video cover image.
- **scene** (string) - Required - The scene to share to. Possible values: WXSceneSession, WXSceneTimeline, WXSceneFavorite.

### Request Example
```json
{
  "title": "My Awesome Video",
  "description": "Check out this cool video I made!",
  "videoUrl": "https://example.com/videos/main.mp4",
  "videoLowBandUrl": "https://example.com/videos/main-low.mp4",
  "coverUrl": "https://example.com/videos/thumbnail.jpg",
  "scene": "WXSceneSession"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful sharing.

#### Response Example
```json
{
  "message": "Video shared successfully"
}
```
```

--------------------------------

### Request Subscribe Message

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Requests user subscription to template messages for notifications.

```APIDOC
## POST /requestSubscribeMessage

### Description
Requests the user to subscribe to a template message. Users who subscribe can receive notifications from your service account.

### Method
POST

### Endpoint
/requestSubscribeMessage

### Parameters
#### Request Body
- **scene** (number) - Required - Scene value (e.g., 0 for normal)
- **templateId** (string) - Required - Template ID obtained from the WeChat MP platform
- **reserved** (string) - Optional - Custom reserved field

### Request Example
{
  "scene": 0,
  "templateId": "TEMPLATE_ID_FROM_WECHAT",
  "reserved": "order_notification"
}

### Response
#### Success Response (200)
- **message** (string) - Indicates successful subscription request.

#### Response Example
{
  "message": "Successfully subscribed to notifications"
}
```

--------------------------------

### Initiate WeChat Authentication Request

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Send an OAuth authentication request using sendAuthRequest. This redirects the user to WeChat for authorization and returns an authorization code upon success. Handle the response to exchange the code for an access token on your backend.

```typescript
import { registerApp, sendAuthRequest } from 'native-wechat';
import { Button, Text, Alert } from 'react-native';

// Response type structure:
// {
//   type: 'SendAuthResp',
//   errorCode: 0,
//   errorStr: null,
//   data: {
//     code: 'authorization_code_here',
//     country: 'CN',
//     lang: 'zh_CN',
//     state: 'custom_state'
//   }
// }

function WechatLoginButton() {
  const handleLogin = async () => {
    try {
      const response = await sendAuthRequest({
        scope: 'snsapi_userinfo', // Request user info permission
        state: 'random_state_string' // Optional: state for security verification
      });

      const { code, country, lang, state } = response.data;

      // Send code to your backend to exchange for access token
      const result = await fetch('https://yourapi.com/auth/wechat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ code, state })
      });

      const userData = await result.json();
      console.log('User authenticated:', userData);

    } catch (error) {
      Alert.alert('Login Failed', error.message);
    }
  };

  return <Button title="Login with WeChat" onPress={handleLogin} />;
}
```

--------------------------------

### Share Text to WeChat Moments

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This function shares text content to WeChat Moments. It requires importing 'shareText' and 'NativeWechatConstants' from 'native-wechat'.

```typescript
import { shareText, NativeWechatConstants } from 'native-wechat';

async function shareToMoments() {
  try {
    // Share to WeChat Moments
    await shareText({
      text: 'Having a great day! #ReactNative',
      scene: NativeWechatConstants.WXSceneTimeline
    });
  } catch (error) {
    console.error('Failed to share to moments:', error);
  }
}
```

--------------------------------

### Share Text to WeChat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

This endpoint allows sharing plain text content to WeChat. You can specify the scene (chat, Moments, or Favorites) where the text will be shared.

```APIDOC
## POST /shareText

### Description
Shares text content to WeChat. The scene parameter determines where the content is shared (chat session, moments, or favorites).

### Method
POST

### Endpoint
/shareText

### Parameters
#### Request Body
- **text** (string) - Required - The text content to share.
- **scene** (string) - Required - The scene to share to. Possible values: WXSceneSession, WXSceneTimeline, WXSceneFavorite.

### Request Example
```json
{
  "text": "Check out this amazing React Native app!",
  "scene": "WXSceneSession"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful sharing.

#### Response Example
```json
{
  "message": "Text shared successfully"
}
```
```

--------------------------------

### Send WeChat Auth Request

Source: https://github.com/hector-zhuang/native-wechat/blob/main/readme.md

Initiates an authentication request to WeChat to obtain a user code. This API is promisified and resolves with data containing the code upon user confirmation.

```jsx
import {registerApp, sendAuthRequest} from 'native-wechat';
import {Button, Text} from 'react-native';
import {verifyWechatCode} from '@/api/auth/wechat'

useEffect(()=>{
	registerApp('wx964290141ebe9b7b');
}, [])

const onButtonClicked = async () =>{
  const {data: {code}} = await sendAuthRequest();
  
  await verifyWechatCode(code);
}

return <Button onClick={onButtonClicked}>
  <Text>Send Auth Request</Text>
</Button>
```

--------------------------------

### Request WeChat Payment

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Initiates a WeChat Pay payment request. The payment parameters must be generated by your backend server using WeChat's payment API.

```typescript
import { requestPayment } from 'native-wechat';

// Response type for successful payment:
// {
//   type: 'PayResp',
//   errorCode: 0,
//   errorStr: null,
//   data: {}
// }

async function processWechatPayment(orderId: string, amount: number) {
  try {
    // Step 1: Get payment parameters from your backend
    const paymentResponse = await fetch('https://yourapi.com/payment/wechat/create', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ orderId, amount })
    });

    const paymentParams = await paymentResponse.json();
    // Backend returns: { partnerId, prepayId, nonceStr, timeStamp, sign }

    // Step 2: Request payment via WeChat
    const result = await requestPayment({
      partnerId: paymentParams.partnerId, // Merchant ID
      prepayId: paymentParams.prepayId, // Prepay ID from WeChat
      nonceStr: paymentParams.nonceStr, // Random string
      timeStamp: paymentParams.timeStamp, // Unix timestamp as string
      sign: paymentParams.sign // Signature from backend
    });

    if (result.errorCode === 0) {
      console.log('Payment successful!');
      // Verify payment on backend
      await fetch('https://yourapi.com/payment/verify', {
        method: 'POST',
        body: JSON.stringify({ orderId })
      });
    }

    return result;
  } catch (error) {
    console.error('Payment failed:', error.message);
    throw error;
  }
}
```

--------------------------------

### Share Image from URL to WeChat Chat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Shares an image from a remote URL to a WeChat chat session. The 'shareImage' function handles downloading and compression.

```typescript
import { shareImage, NativeWechatConstants } from 'native-wechat';

async function shareImageToChat(imageUrl: string) {
  try {
    // Share from remote URL
    await shareImage({
      src: 'https://example.com/images/photo.jpg',
      scene: NativeWechatConstants.WXSceneSession
    });
    console.log('Image shared successfully');
  } catch (error) {
    console.error('Failed to share image:', error);
  }
}
```

--------------------------------

### Share Text to WeChat Chat

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Use this function to share text content to a specific WeChat chat session. Ensure the 'native-wechat' library is imported.

```typescript
import { shareText, NativeWechatConstants } from 'native-wechat';

// Available scenes from NativeWechatConstants:
// - WXSceneSession: Share to chat session (friend/group)
// - WXSceneTimeline: Share to Moments (朋友圈)
// - WXSceneFavorite: Add to Favorites

async function shareTextContent() {
  try {
    // Share to a chat session
    await shareText({
      text: 'Check out this amazing React Native app!',
      scene: NativeWechatConstants.WXSceneSession
    });
    console.log('Text shared successfully');
  } catch (error) {
    console.error('Failed to share text:', error);
  }
}
```

--------------------------------

### Native WeChat Response Type and Error Handling

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Defines the standard `NativeWechatResponse` structure for consistent API error handling. Includes a generic function to process responses and handle common WeChat error codes.

```typescript
import { NativeWechatResponse } from 'native-wechat';

// Generic response structure
type NativeWechatResponse<T = Record<string, unknown>> = {
  type: string; // Response type identifier (e.g., 'SendAuthResp', 'PayResp')
  errorCode: number; // 0 for success, non-zero for errors
  errorStr: string | null; // Error description if errorCode is non-zero
  transaction: string | null; // Transaction identifier
  data: T; // Response-specific data
};

// Error handling example
async function handleWechatOperation<T>(
  operation: () => Promise<NativeWechatResponse<T>>
): Promise<T | null> {
  try {
    const response = await operation();

    if (response.errorCode !== 0) {
      // Handle WeChat-specific errors
      switch (response.errorCode) {
        case -1:
          console.error('Common error');
          break;
        case -2:
          console.error('User cancelled');
          break;
        case -3:
          console.error('Sent failed');
          break;
        case -4:
          console.error('Auth denied');
          break;
        case -5:
          console.error('Unsupported');
          break;
        default:
          console.error(`WeChat error (${response.errorCode}): ${response.errorStr}`);
      }
      return null;
    }

    return response.data;
  } catch (error) {
    console.error('Operation failed:', error);
    return null;
  }
}
```

--------------------------------

### NativeWechatResponse Type

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Defines the standard response structure for all promisified WeChat API calls, ensuring consistent error handling and data retrieval.

```APIDOC
## NativeWechatResponse Type

### Description
The standard response type returned by all promisified WeChat APIs. Provides consistent error handling and response data structure.

### Type Definition
```typescript
type NativeWechatResponse<T = Record<string, unknown>> = {
  type: string; // Response type identifier (e.g., 'SendAuthResp', 'PayResp')
  errorCode: number; // 0 for success, non-zero for errors
  errorStr: string | null; // Error description if errorCode is non-zero
  transaction: string | null; // Transaction identifier
  data: T; // Response-specific data
};
```

### Error Codes
- **0**: Success
- **-1**: Common error
- **-2**: User cancelled
- **-3**: Sent failed
- **-4**: Auth denied
- **-5**: Unsupported

### Usage Example
```typescript
import { NativeWechatResponse } from 'native-wechat';

async function handleWechatOperation<T>(
  operation: () => Promise<NativeWechatResponse<T>>
): Promise<T | null> {
  try {
    const response = await operation();

    if (response.errorCode !== 0) {
      // Handle WeChat-specific errors
      switch (response.errorCode) {
        case -1:
          console.error('Common error');
          break;
        case -2:
          console.error('User cancelled');
          break;
        case -3:
          console.error('Sent failed');
          break;
        case -4:
          console.error('Auth denied');
          break;
        case -5:
          console.error('Unsupported');
          break;
        default:
          console.error(`WeChat error (${response.errorCode}): ${response.errorStr}`);
      }
      return null;
    }

    return response.data;
  } catch (error) {
    console.error('Operation failed:', error);
    return null;
  }
}
```
```

--------------------------------

### NativeWechatResponse Type Definition

Source: https://github.com/hector-zhuang/native-wechat/blob/main/readme.md

Defines the generic response structure for all promisified APIs in the Native WeChat library. It includes type, error codes, error messages, and the actual data payload.

```typescript
export type NativeWechatResponse<T = Record<string, unknown>> = {
  type: string;
  errorCode: number;
  errorStr: string | null;
  data: T;
};
```

--------------------------------

### Request WeChat Subscribe Message

Source: https://context7.com/hector-zhuang/native-wechat/llms.txt

Requests the user to subscribe to a template message. Users who subscribe can receive notifications from your service account.

```typescript
import { requestSubscribeMessage, NativeWechatConstants } from 'native-wechat';

async function subscribeToOrderNotifications() {
  try {
    await requestSubscribeMessage({
      scene: NativeWechatConstants.WXSceneSession, // Scene value (0 for normal)
      templateId: 'TEMPLATE_ID_FROM_WECHAT', // Template ID from WeChat MP platform
      reserved: 'order_notification' // Optional: custom reserved field
    });
    console.log('Successfully subscribed to notifications');
  } catch (error) {
    console.error('Failed to subscribe:', error);
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.