@line/bot-sdk

  • Version 7.4.0
  • Published
  • 264 kB
  • 6 dependencies
  • Apache-2.0 license

Install

npm i @line/bot-sdk
yarn add @line/bot-sdk
pnpm add @line/bot-sdk

Overview

Node.js SDK for LINE Messaging API

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable LINE_REQUEST_ID_HTTP_HEADER_NAME

const LINE_REQUEST_ID_HTTP_HEADER_NAME: string;

    variable LINE_SIGNATURE_HTTP_HEADER_NAME

    const LINE_SIGNATURE_HTTP_HEADER_NAME: string;

      Functions

      function middleware

      middleware: (config: Types.MiddlewareConfig) => Middleware;

        function validateSignature

        validateSignature: (
        body: string | Buffer,
        channelSecret: string,
        signature: string
        ) => boolean;

          Classes

          class Client

          class Client {}

            constructor

            constructor(config: Types.ClientConfig);

              property config

              config: Types.ClientConfig;

                method broadcast

                broadcast: (
                messages: Types.Message | Types.Message[],
                notificationDisabled?: boolean
                ) => Promise<Types.MessageAPIResponseBase>;

                  method changeAudienceGroupAuthorityLevel

                  changeAudienceGroupAuthorityLevel: (
                  authorityLevel: Types.AudienceGroupAuthorityLevel
                  ) => Promise<{}>;

                    method createClickAudienceGroup

                    createClickAudienceGroup: (clickAudienceGroup: {
                    description: string;
                    requestId: string;
                    clickUrl?: string;
                    }) => Promise<
                    { audienceGroupId: number; type: string; created: number } & {
                    description: string;
                    requestId: string;
                    clickUrl?: string;
                    }
                    >;

                      method createImpAudienceGroup

                      createImpAudienceGroup: (impAudienceGroup: {
                      requestId: string;
                      description: string;
                      }) => Promise<
                      { audienceGroupId: number; type: string; created: number } & {
                      requestId: string;
                      description: string;
                      }
                      >;

                        method createRichMenu

                        createRichMenu: (richMenu: Types.RichMenu) => Promise<string>;

                          method createRichMenuAlias

                          createRichMenuAlias: (
                          richMenuId: string,
                          richMenuAliasId: string
                          ) => Promise<{}>;

                            method createUploadAudienceGroup

                            createUploadAudienceGroup: (uploadAudienceGroup: {
                            description: string;
                            isIfaAudience?: boolean;
                            audiences?: { id: string }[];
                            uploadDescription?: string;
                            }) => Promise<{
                            audienceGroupId: number;
                            type: string;
                            description: string;
                            created: number;
                            }>;

                              method createUploadAudienceGroupByFile

                              createUploadAudienceGroupByFile: (uploadAudienceGroup: {
                              description: string;
                              isIfaAudience?: boolean;
                              uploadDescription?: string;
                              file: Buffer | Readable;
                              }) => Promise<{
                              audienceGroupId: number;
                              type: 'UPLOAD';
                              description: string;
                              created: number;
                              }>;

                                method deleteAudienceGroup

                                deleteAudienceGroup: (audienceGroupId: string) => Promise<{}>;

                                  method deleteDefaultRichMenu

                                  deleteDefaultRichMenu: () => Promise<{}>;

                                    method deleteRichMenu

                                    deleteRichMenu: (richMenuId: string) => Promise<any>;

                                      method deleteRichMenuAlias

                                      deleteRichMenuAlias: (richMenuAliasId: string) => Promise<{}>;

                                        method getAudienceGroup

                                        getAudienceGroup: (audienceGroupId: string) => Promise<Types.AudienceGroup>;

                                          method getAudienceGroupAuthorityLevel

                                          getAudienceGroupAuthorityLevel: () => Promise<{
                                          authorityLevel: Types.AudienceGroupAuthorityLevel;
                                          }>;

                                            method getAudienceGroups

                                            getAudienceGroups: (
                                            page: number,
                                            description?: string,
                                            status?: Types.AudienceGroupStatus,
                                            size?: number,
                                            createRoute?: Types.AudienceGroupCreateRoute,
                                            includesExternalPublicGroups?: boolean
                                            ) => Promise<{
                                            audienceGroups: Types.AudienceGroups;
                                            hasNextPage: boolean;
                                            totalCount: number;
                                            readWriteAudienceGroupTotalCount: number;
                                            page: number;
                                            size: number;
                                            }>;

                                              method getBotFollowersIds

                                              getBotFollowersIds: () => Promise<string[]>;

                                                method getBotInfo

                                                getBotInfo: () => Promise<Types.BotInfoResponse>;

                                                  method getDefaultRichMenuId

                                                  getDefaultRichMenuId: () => Promise<string>;

                                                    method getFriendDemographics

                                                    getFriendDemographics: () => Promise<Types.FriendDemographics>;

                                                      method getGroupMemberIds

                                                      getGroupMemberIds: (groupId: string) => Promise<string[]>;

                                                        method getGroupMemberProfile

                                                        getGroupMemberProfile: (
                                                        groupId: string,
                                                        userId: string
                                                        ) => Promise<Types.Profile>;

                                                          method getGroupMembersCount

                                                          getGroupMembersCount: (groupId: string) => Promise<Types.MembersCountResponse>;

                                                            method getGroupSummary

                                                            getGroupSummary: (groupId: string) => Promise<Types.GroupSummaryResponse>;

                                                              method getLinkToken

                                                              getLinkToken: (userId: string) => Promise<string>;

                                                                method getMessageContent

                                                                getMessageContent: (messageId: string) => Promise<Readable>;

                                                                  method getNarrowcastProgress

                                                                  getNarrowcastProgress: (
                                                                  requestId: string
                                                                  ) => Promise<Types.NarrowcastProgressResponse>;

                                                                    method getNumberOfFollowers

                                                                    getNumberOfFollowers: (date: string) => Promise<Types.NumberOfFollowersResponse>;

                                                                      method getNumberOfMessageDeliveries

                                                                      getNumberOfMessageDeliveries: (
                                                                      date: string
                                                                      ) => Promise<Types.NumberOfMessageDeliveriesResponse>;

                                                                        method getNumberOfMessagesSentThisMonth

                                                                        getNumberOfMessagesSentThisMonth: () => Promise<Types.NumberOfMessagesSentThisMonth>;

                                                                          method getNumberOfSentBroadcastMessages

                                                                          getNumberOfSentBroadcastMessages: (
                                                                          date: string
                                                                          ) => Promise<Types.NumberOfMessagesSentResponse>;

                                                                            method getNumberOfSentMulticastMessages

                                                                            getNumberOfSentMulticastMessages: (
                                                                            date: string
                                                                            ) => Promise<Types.NumberOfMessagesSentResponse>;

                                                                              method getNumberOfSentPushMessages

                                                                              getNumberOfSentPushMessages: (
                                                                              date: string
                                                                              ) => Promise<Types.NumberOfMessagesSentResponse>;

                                                                                method getNumberOfSentReplyMessages

                                                                                getNumberOfSentReplyMessages: (
                                                                                date: string
                                                                                ) => Promise<Types.NumberOfMessagesSentResponse>;

                                                                                  method getProfile

                                                                                  getProfile: (userId: string) => Promise<Types.Profile>;

                                                                                    method getRichMenu

                                                                                    getRichMenu: (richMenuId: string) => Promise<Types.RichMenuResponse>;

                                                                                      method getRichMenuAlias

                                                                                      getRichMenuAlias: (
                                                                                      richMenuAliasId: string
                                                                                      ) => Promise<Types.GetRichMenuAliasResponse>;

                                                                                        method getRichMenuAliasList

                                                                                        getRichMenuAliasList: () => Promise<Types.GetRichMenuAliasListResponse>;

                                                                                          method getRichMenuIdOfUser

                                                                                          getRichMenuIdOfUser: (userId: string) => Promise<string>;

                                                                                            method getRichMenuImage

                                                                                            getRichMenuImage: (richMenuId: string) => Promise<Readable>;

                                                                                              method getRichMenuList

                                                                                              getRichMenuList: () => Promise<Array<Types.RichMenuResponse>>;

                                                                                                method getRoomMemberIds

                                                                                                getRoomMemberIds: (roomId: string) => Promise<string[]>;

                                                                                                  method getRoomMemberProfile

                                                                                                  getRoomMemberProfile: (roomId: string, userId: string) => Promise<Types.Profile>;

                                                                                                    method getRoomMembersCount

                                                                                                    getRoomMembersCount: (roomId: string) => Promise<Types.MembersCountResponse>;

                                                                                                      method getTargetLimitForAdditionalMessages

                                                                                                      getTargetLimitForAdditionalMessages: () => Promise<Types.TargetLimitForAdditionalMessages>;

                                                                                                        method getUserInteractionStatistics

                                                                                                        getUserInteractionStatistics: (
                                                                                                        requestId: string
                                                                                                        ) => Promise<Types.UserInteractionStatistics>;

                                                                                                          method getWebhookEndpointInfo

                                                                                                          getWebhookEndpointInfo: () => Promise<Types.WebhookEndpointInfoResponse>;

                                                                                                            method leaveGroup

                                                                                                            leaveGroup: (groupId: string) => Promise<any>;

                                                                                                              method leaveRoom

                                                                                                              leaveRoom: (roomId: string) => Promise<any>;

                                                                                                                method linkRichMenuToMultipleUsers

                                                                                                                linkRichMenuToMultipleUsers: (
                                                                                                                richMenuId: string,
                                                                                                                userIds: string[]
                                                                                                                ) => Promise<any>;

                                                                                                                  method linkRichMenuToUser

                                                                                                                  linkRichMenuToUser: (userId: string, richMenuId: string) => Promise<any>;

                                                                                                                    method multicast

                                                                                                                    multicast: (
                                                                                                                    to: string[],
                                                                                                                    messages: Types.Message | Types.Message[],
                                                                                                                    notificationDisabled?: boolean
                                                                                                                    ) => Promise<Types.MessageAPIResponseBase>;

                                                                                                                      method narrowcast

                                                                                                                      narrowcast: (
                                                                                                                      messages: Types.Message | Types.Message[],
                                                                                                                      recipient?: Types.ReceieptObject,
                                                                                                                      filter?: { demographic: Types.DemographicFilterObject },
                                                                                                                      limit?: { max?: number; upToRemainingQuota?: boolean },
                                                                                                                      notificationDisabled?: boolean
                                                                                                                      ) => Promise<Types.MessageAPIResponseBase>;

                                                                                                                        method pushMessage

                                                                                                                        pushMessage: (
                                                                                                                        to: string,
                                                                                                                        messages: Types.Message | Types.Message[],
                                                                                                                        notificationDisabled?: boolean
                                                                                                                        ) => Promise<Types.MessageAPIResponseBase>;

                                                                                                                          method replyMessage

                                                                                                                          replyMessage: (
                                                                                                                          replyToken: string,
                                                                                                                          messages: Types.Message | Types.Message[],
                                                                                                                          notificationDisabled?: boolean
                                                                                                                          ) => Promise<Types.MessageAPIResponseBase>;

                                                                                                                            method setDefaultRichMenu

                                                                                                                            setDefaultRichMenu: (richMenuId: string) => Promise<{}>;

                                                                                                                              method setDescriptionAudienceGroup

                                                                                                                              setDescriptionAudienceGroup: (
                                                                                                                              description: string,
                                                                                                                              audienceGroupId: string
                                                                                                                              ) => Promise<{}>;

                                                                                                                                method setRequestOptionOnce

                                                                                                                                setRequestOptionOnce: (option: Partial<RequestOption>) => void;

                                                                                                                                  method setRichMenuImage

                                                                                                                                  setRichMenuImage: (
                                                                                                                                  richMenuId: string,
                                                                                                                                  data: Buffer | Readable,
                                                                                                                                  contentType?: string
                                                                                                                                  ) => Promise<any>;

                                                                                                                                    method setWebhookEndpointUrl

                                                                                                                                    setWebhookEndpointUrl: (endpoint: string) => Promise<{}>;

                                                                                                                                      method testWebhookEndpoint

                                                                                                                                      testWebhookEndpoint: (
                                                                                                                                      endpoint?: string
                                                                                                                                      ) => Promise<Types.TestWebhookEndpointResponse>;

                                                                                                                                        method unlinkRichMenuFromUser

                                                                                                                                        unlinkRichMenuFromUser: (userId: string) => Promise<any>;

                                                                                                                                          method unlinkRichMenusFromMultipleUsers

                                                                                                                                          unlinkRichMenusFromMultipleUsers: (userIds: string[]) => Promise<any>;

                                                                                                                                            method updateRichMenuAlias

                                                                                                                                            updateRichMenuAlias: (
                                                                                                                                            richMenuAliasId: string,
                                                                                                                                            richMenuId: string
                                                                                                                                            ) => Promise<{}>;

                                                                                                                                              method updateUploadAudienceGroup

                                                                                                                                              updateUploadAudienceGroup: (
                                                                                                                                              uploadAudienceGroup: {
                                                                                                                                              audienceGroupId: number;
                                                                                                                                              description?: string;
                                                                                                                                              uploadDescription?: string;
                                                                                                                                              audiences: { id: string }[];
                                                                                                                                              },
                                                                                                                                              httpConfig?: any
                                                                                                                                              ) => Promise<{}>;

                                                                                                                                                method updateUploadAudienceGroupByFile

                                                                                                                                                updateUploadAudienceGroupByFile: (
                                                                                                                                                uploadAudienceGroup: {
                                                                                                                                                audienceGroupId: number;
                                                                                                                                                uploadDescription?: string;
                                                                                                                                                file: Buffer | Readable;
                                                                                                                                                },
                                                                                                                                                httpConfig?: any
                                                                                                                                                ) => Promise<{}>;

                                                                                                                                                  class HTTPError

                                                                                                                                                  class HTTPError extends Error {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(
                                                                                                                                                    message: string,
                                                                                                                                                    statusCode: number,
                                                                                                                                                    statusMessage: string,
                                                                                                                                                    originalError: any
                                                                                                                                                    );

                                                                                                                                                      property originalError

                                                                                                                                                      originalError: any;

                                                                                                                                                        property statusCode

                                                                                                                                                        statusCode: number;

                                                                                                                                                          property statusMessage

                                                                                                                                                          statusMessage: string;

                                                                                                                                                            class JSONParseError

                                                                                                                                                            class JSONParseError extends Error {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(message: string, raw: any);

                                                                                                                                                                property raw

                                                                                                                                                                raw: any;

                                                                                                                                                                  class OAuth

                                                                                                                                                                  class OAuth {}

                                                                                                                                                                    constructor

                                                                                                                                                                    constructor();

                                                                                                                                                                      method getChannelAccessTokenKeyIdsV2_1

                                                                                                                                                                      getChannelAccessTokenKeyIdsV2_1: (
                                                                                                                                                                      client_assertion: string
                                                                                                                                                                      ) => Promise<{ key_ids: string[] }>;

                                                                                                                                                                        method issueAccessToken

                                                                                                                                                                        issueAccessToken: (
                                                                                                                                                                        client_id: string,
                                                                                                                                                                        client_secret: string
                                                                                                                                                                        ) => Promise<Types.ChannelAccessToken>;

                                                                                                                                                                          method issueChannelAccessTokenV2_1

                                                                                                                                                                          issueChannelAccessTokenV2_1: (
                                                                                                                                                                          client_assertion: string
                                                                                                                                                                          ) => Promise<Types.ChannelAccessToken>;

                                                                                                                                                                            method revokeAccessToken

                                                                                                                                                                            revokeAccessToken: (access_token: string) => Promise<{}>;

                                                                                                                                                                              method revokeChannelAccessTokenV2_1

                                                                                                                                                                              revokeChannelAccessTokenV2_1: (
                                                                                                                                                                              client_id: string,
                                                                                                                                                                              client_secret: string,
                                                                                                                                                                              access_token: string
                                                                                                                                                                              ) => Promise<{}>;

                                                                                                                                                                                class ReadError

                                                                                                                                                                                class ReadError extends Error {}

                                                                                                                                                                                  constructor

                                                                                                                                                                                  constructor(originalError: Error);

                                                                                                                                                                                    class RequestError

                                                                                                                                                                                    class RequestError extends Error {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(message: string, code: string, originalError: Error);

                                                                                                                                                                                        property code

                                                                                                                                                                                        code: string;

                                                                                                                                                                                          class SignatureValidationFailed

                                                                                                                                                                                          class SignatureValidationFailed extends Error {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(message: string, signature?: string);

                                                                                                                                                                                              property signature

                                                                                                                                                                                              signature?: string;

                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                interface ClientConfig

                                                                                                                                                                                                interface ClientConfig extends Config {}

                                                                                                                                                                                                  property channelAccessToken

                                                                                                                                                                                                  channelAccessToken: string;

                                                                                                                                                                                                    property httpConfig

                                                                                                                                                                                                    httpConfig?: Partial<AxiosRequestConfig>;

                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                      interface Config {}

                                                                                                                                                                                                        property channelAccessToken

                                                                                                                                                                                                        channelAccessToken?: string;

                                                                                                                                                                                                          property channelSecret

                                                                                                                                                                                                          channelSecret?: string;

                                                                                                                                                                                                            interface MiddlewareConfig

                                                                                                                                                                                                            interface MiddlewareConfig extends Config {}

                                                                                                                                                                                                              property channelSecret

                                                                                                                                                                                                              channelSecret: string;

                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                type AccountLinkEvent

                                                                                                                                                                                                                type AccountLinkEvent = ReplyableEvent & {
                                                                                                                                                                                                                type: 'accountLink';
                                                                                                                                                                                                                link: {
                                                                                                                                                                                                                result: 'ok' | 'failed';
                                                                                                                                                                                                                /**
                                                                                                                                                                                                                * Specified nonce when verifying the user ID
                                                                                                                                                                                                                */
                                                                                                                                                                                                                nonce: string;
                                                                                                                                                                                                                };
                                                                                                                                                                                                                };
                                                                                                                                                                                                                • Event object for when a user has linked his/her LINE account with a provider's service account.

                                                                                                                                                                                                                type Action

                                                                                                                                                                                                                type Action<
                                                                                                                                                                                                                ExtraFields = {
                                                                                                                                                                                                                label: string;
                                                                                                                                                                                                                }
                                                                                                                                                                                                                > = (
                                                                                                                                                                                                                | PostbackAction
                                                                                                                                                                                                                | MessageAction
                                                                                                                                                                                                                | URIAction
                                                                                                                                                                                                                | DatetimePickerAction
                                                                                                                                                                                                                | RichMenuSwitchAction
                                                                                                                                                                                                                | {
                                                                                                                                                                                                                type: 'camera';
                                                                                                                                                                                                                }
                                                                                                                                                                                                                | {
                                                                                                                                                                                                                type: 'cameraRoll';
                                                                                                                                                                                                                }
                                                                                                                                                                                                                | {
                                                                                                                                                                                                                type: 'location';
                                                                                                                                                                                                                }
                                                                                                                                                                                                                ) &
                                                                                                                                                                                                                ExtraFields;
                                                                                                                                                                                                                • These are types of actions for your bot to take when a user taps a button or an image in a message.

                                                                                                                                                                                                                  - [Postback action](https://developers.line.biz/en/reference/messaging-api/#postback-action) - [Message action](https://developers.line.biz/en/reference/messaging-api/#message-action) - [URI action](https://developers.line.biz/en/reference/messaging-api/#uri-action) - [Datetime picker action](https://developers.line.biz/en/reference/messaging-api/#datetime-picker-action) - [Rich menu switch action](https://developers.line.biz/en/reference/messaging-api/#richmenu-switch-action) - [Camera action](https://developers.line.biz/en/reference/messaging-api/#camera-action) - [Camera roll action](https://developers.line.biz/en/reference/messaging-api/#camera-roll-action) - [Location action](https://developers.line.biz/en/reference/messaging-api/#location-action)

                                                                                                                                                                                                                type AltURI

                                                                                                                                                                                                                type AltURI = {
                                                                                                                                                                                                                desktop: string;
                                                                                                                                                                                                                };
                                                                                                                                                                                                                • URI opened on LINE for macOS and Windows when the action is performed (Max: 1000 characters) If the altUri.desktop property is set, the uri property is ignored on LINE for macOS and Windows. The available schemes are http, https, line, and tel. For more information about the LINE URL scheme, see Using the LINE URL scheme. This property is supported on the following version of LINE.

                                                                                                                                                                                                                  LINE 5.12.0 or later for macOS and Windows Note: The altUri.desktop property is supported only when you set URI actions in Flex Messages.

                                                                                                                                                                                                                type Area

                                                                                                                                                                                                                type Area = {
                                                                                                                                                                                                                /**
                                                                                                                                                                                                                * Horizontal position relative to the top-left corner of the area
                                                                                                                                                                                                                */
                                                                                                                                                                                                                x: number;
                                                                                                                                                                                                                /**
                                                                                                                                                                                                                * Vertical position relative to the top-left corner of the area
                                                                                                                                                                                                                */
                                                                                                                                                                                                                y: number;
                                                                                                                                                                                                                /**
                                                                                                                                                                                                                * Width of the tappable area
                                                                                                                                                                                                                */
                                                                                                                                                                                                                width: number;
                                                                                                                                                                                                                /**
                                                                                                                                                                                                                * Height of the tappable area
                                                                                                                                                                                                                */
                                                                                                                                                                                                                height: number;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  type AudienceGroup

                                                                                                                                                                                                                  type AudienceGroup = _AudienceGroup & {
                                                                                                                                                                                                                  jobs: AudienceGroupJob[];
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    type AudienceGroupAuthorityLevel

                                                                                                                                                                                                                    type AudienceGroupAuthorityLevel = 'PUBLIC' | 'PRIVATE';

                                                                                                                                                                                                                      type AudienceGroupCreateRoute

                                                                                                                                                                                                                      type AudienceGroupCreateRoute = 'OA_MANAGER' | 'MESSAGING_API';

                                                                                                                                                                                                                        type AudienceGroups

                                                                                                                                                                                                                        type AudienceGroups = _AudienceGroup[];

                                                                                                                                                                                                                          type AudienceGroupStatus

                                                                                                                                                                                                                          type AudienceGroupStatus = 'IN_PROGRESS' | 'READY' | 'EXPIRED' | 'FAILED';

                                                                                                                                                                                                                            type AudioEventMessage

                                                                                                                                                                                                                            type AudioEventMessage = {
                                                                                                                                                                                                                            type: 'audio';
                                                                                                                                                                                                                            duration: number;
                                                                                                                                                                                                                            contentProvider: ContentProvider<false>;
                                                                                                                                                                                                                            } & EventMessageBase;
                                                                                                                                                                                                                            • Message object which contains the audio content sent from the source. The binary audio data can be retrieved using Client#getMessageContent.

                                                                                                                                                                                                                            type AudioMessage

                                                                                                                                                                                                                            type AudioMessage = MessageCommon & {
                                                                                                                                                                                                                            type: 'audio';
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * URL of audio file (Max: 2000 characters)
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * - **HTTPS**
                                                                                                                                                                                                                            * - m4a
                                                                                                                                                                                                                            * - Max: 1 minute
                                                                                                                                                                                                                            * - Max: 10 MB
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            originalContentUrl: string;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Length of audio file (milliseconds)
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            duration: number;
                                                                                                                                                                                                                            };
                                                                                                                                                                                                                            • See Also

                                                                                                                                                                                                                              • [Audio message](https://developers.line.biz/en/reference/messaging-api/#audio-message)

                                                                                                                                                                                                                            type Background

                                                                                                                                                                                                                            type Background = {
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The type of background used. Specify these values:
                                                                                                                                                                                                                            * - `linearGradient`: Linear gradient. For more information, see [Linear gradient backgrounds](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#linear-gradient-bg) in the Messaging API documentation.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            type: 'linearGradient';
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The angle at which a linear gradient moves. Specify the angle using an integer value
                                                                                                                                                                                                                            * like `90deg` (90 degrees) or a decimal number like `23.5deg` (23.5 degrees) in the
                                                                                                                                                                                                                            * half-open interval [0, 360). The direction of the linear gradient rotates clockwise as the
                                                                                                                                                                                                                            * angle increases. Given a value of `0deg`, the gradient starts at the bottom and ends at
                                                                                                                                                                                                                            * the top; given a value of `45deg`, the gradient starts at the bottom-left corner and ends
                                                                                                                                                                                                                            * at the top-right corner; given a value of 90deg, the gradient starts at the left and ends
                                                                                                                                                                                                                            * at the right; and given a value of `180deg`, the gradient starts at the top and ends at
                                                                                                                                                                                                                            * the bottom. For more information, see [Direction (angle) of linear gradient backgrounds](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#linear-gradient-bg-angle) in the Messaging API documentation.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            angle: string;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The color at the gradient's starting point. Use a hexadecimal color code in the
                                                                                                                                                                                                                            * `#RRGGBB` or `#RRGGBBAA` format.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            startColor: string;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The color at the gradient's ending point. Use a hexadecimal color code in the
                                                                                                                                                                                                                            * `#RRGGBB` or `#RRGGBBAA` format.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            endColor: string;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The color in the middle of the gradient. Use a hexadecimal color code in the `#RRGGBB`
                                                                                                                                                                                                                            * or `#RRGGBBAA` format. Specify a value for the `background.centerColor` property to
                                                                                                                                                                                                                            * create a gradient that has three colors. For more information, see [Intermediate color stops for linear gradients](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#linear-gradient-bg-center-color) in the
                                                                                                                                                                                                                            * Messaging API documentation.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            centerColor?: string;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The position of the intermediate color stop. Specify an integer or decimal value
                                                                                                                                                                                                                            * between `0%` (the starting point) and `100%` (the ending point). This is `50%` by
                                                                                                                                                                                                                            * default. For more information, see [Intermediate color stops for linear gradients](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#linear-gradient-bg-center-color) in the
                                                                                                                                                                                                                            * Messaging API documentation.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            centerPosition?: string;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              type BeaconEvent

                                                                                                                                                                                                                              type BeaconEvent = ReplyableEvent & {
                                                                                                                                                                                                                              type: 'beacon';
                                                                                                                                                                                                                              beacon: {
                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                              * `leave` will be deprecated
                                                                                                                                                                                                                              */
                                                                                                                                                                                                                              type: 'enter' | 'leave' | 'banner' | 'stay';
                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                              * Hardware ID of the beacon that was detected
                                                                                                                                                                                                                              */
                                                                                                                                                                                                                              hwid: string;
                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                              * Device message of beacon that was detected.
                                                                                                                                                                                                                              *
                                                                                                                                                                                                                              * This message consists of data generated by the beacon to send notifications to bots.
                                                                                                                                                                                                                              * Only included in webhooks from devices that support the "device message" property.
                                                                                                                                                                                                                              * For more information, see the
                                                                                                                                                                                                                              * [LINE Simple Beacon specification](https://github.com/line/line-simple-beacon/blob/master/README.en.md/#line-simple-beacon-frame).
                                                                                                                                                                                                                              */
                                                                                                                                                                                                                              dm?: string;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              • Event object for when a user enters or leaves the range of a [LINE Beacon](https://developers.line.biz/en/docs/messaging-api/using-beacons/).

                                                                                                                                                                                                                              type BotInfoResponse

                                                                                                                                                                                                                              type BotInfoResponse = {
                                                                                                                                                                                                                              userId: string;
                                                                                                                                                                                                                              basicId: string;
                                                                                                                                                                                                                              premiumId?: string;
                                                                                                                                                                                                                              displayName: string;
                                                                                                                                                                                                                              pictureUrl?: string;
                                                                                                                                                                                                                              chatMode: 'chat' | 'bot';
                                                                                                                                                                                                                              markAsReadMode: 'auto' | 'manual';
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              • Response body of get bot info.

                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                • [Get bot info](https://developers.line.biz/en/reference/messaging-api/#get-bot-info)

                                                                                                                                                                                                                              type ChannelAccessToken

                                                                                                                                                                                                                              type ChannelAccessToken = {
                                                                                                                                                                                                                              access_token: string;
                                                                                                                                                                                                                              expires_in: number;
                                                                                                                                                                                                                              token_type: 'Bearer';
                                                                                                                                                                                                                              key_id?: string;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                type ContentProvider

                                                                                                                                                                                                                                type ContentProvider<WithPreview extends boolean = true> =
                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * The content is provided by LINE.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * The data itself can be retrieved from the content API.
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                type: 'line';
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * The content is provided by a provider other than LINE
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                type: 'external';
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * URL of the content. Only included when contentProvider.type is external.
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                originalContentUrl: string;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * URL of the content preview. Only included when contentProvider.type is external.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * For contents without preview (e.g. audio), it's undefined.
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                previewImageUrl: WithPreview extends true ? string : undefined;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  type DatetimePickerAction

                                                                                                                                                                                                                                  type DatetimePickerAction = {
                                                                                                                                                                                                                                  type: 'datetimepicker';
                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                  * String returned via webhook in the `postback.data` property of the
                                                                                                                                                                                                                                  * postback event (Max: 300 characters)
                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                  data: string;
                                                                                                                                                                                                                                  mode: 'date' | 'time' | 'datetime';
                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                  * Initial value of date or time
                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                  initial?: string;
                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                  * Largest date or time value that can be selected. Must be greater than the
                                                                                                                                                                                                                                  * `min` value.
                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                  max?: string;
                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                  * Smallest date or time value that can be selected. Must be less than the
                                                                                                                                                                                                                                  * `max` value.
                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                  min?: string;
                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                  • When a control associated with this action is tapped, a [postback event](https://developers.line.biz/en/reference/messaging-api/#postback-event) is returned via webhook with the date and time selected by the user from the date and time selection dialog.

                                                                                                                                                                                                                                    The datetime picker action does not support time zones.

                                                                                                                                                                                                                                    #### Date and time format

                                                                                                                                                                                                                                    The date and time formats for the initial, max, and min values are shown below. The full-date, time-hour, and time-minute formats follow the [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) protocol.

                                                                                                                                                                                                                                    | Mode | Format | Example | | -------- | ------------------------------------------------------------ | -------------------------------- | | date | full-date (Max: 2100-12-31; Min: 1900-01-01) | 2017-06-18 | | time | time-hour:time-minute (Max: 23:59; Min: 00:00) | 00:0006:1523:59 | | datetime | full-dateTtime-hour:time-minute or full-datettime-hour:time-minute (Max: 2100-12-31T23:59; Min: 1900-01-01T00:00) | 2017-06-18T06:152017-06-18t06:15 |

                                                                                                                                                                                                                                  type DemographicFilterObject

                                                                                                                                                                                                                                  type DemographicFilterObject =
                                                                                                                                                                                                                                  | DemographicObject
                                                                                                                                                                                                                                  | FilterOperatorObject<DemographicObject>;

                                                                                                                                                                                                                                    type DeviceLinkEvent

                                                                                                                                                                                                                                    type DeviceLinkEvent = ReplyableEvent & {
                                                                                                                                                                                                                                    type: 'things';
                                                                                                                                                                                                                                    things: {
                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                    * Device ID of the LINE Things-compatible device that was linked with LINE
                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                    deviceId: string;
                                                                                                                                                                                                                                    type: 'link';
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    • Indicates that a LINE Things-compatible device has been linked with LINE by a user operation. For more information, see [Receiving device link events via webhook](https://developers.line.biz/en/docs/line-things/develop-bot/#link-event).

                                                                                                                                                                                                                                    type DeviceUnlinkEvent

                                                                                                                                                                                                                                    type DeviceUnlinkEvent = ReplyableEvent & {
                                                                                                                                                                                                                                    type: 'things';
                                                                                                                                                                                                                                    things: {
                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                    * Device ID of the LINE Things-compatible device that was unlinked with LINE
                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                    deviceId: string;
                                                                                                                                                                                                                                    type: 'unlink';
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                    • Indicates that a LINE Things-compatible device has been unlinked from LINE by a user operation. For more information, see [Receiving device unlink events via webhook](https://developers.line.biz/en/docs/line-things/develop-bot/#unlink-event).

                                                                                                                                                                                                                                    type EventBase

                                                                                                                                                                                                                                    type EventBase = {
                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                    * Channel state.
                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                    * `active`: The channel is active. You can send a reply message or push message from the bot server that received this webhook event.
                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                    * `standby`: The channel is waiting. The bot server that received this webhook event shouldn't send any messages.
                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                    mode: 'active' | 'standby';
                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                    * Time of the event in milliseconds
                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                    timestamp: number;
                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                    * Source user, group, or room object with information about the source of the event.
                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                    source: EventSource;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      type EventMessage

                                                                                                                                                                                                                                      type EventMessage =
                                                                                                                                                                                                                                      | TextEventMessage
                                                                                                                                                                                                                                      | ImageEventMessage
                                                                                                                                                                                                                                      | VideoEventMessage
                                                                                                                                                                                                                                      | AudioEventMessage
                                                                                                                                                                                                                                      | LocationEventMessage
                                                                                                                                                                                                                                      | FileEventMessage
                                                                                                                                                                                                                                      | StickerEventMessage;

                                                                                                                                                                                                                                        type EventMessageBase

                                                                                                                                                                                                                                        type EventMessageBase = {
                                                                                                                                                                                                                                        id: string;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          type EventSource

                                                                                                                                                                                                                                          type EventSource = User | Group | Room;

                                                                                                                                                                                                                                            type FileEventMessage

                                                                                                                                                                                                                                            type FileEventMessage = {
                                                                                                                                                                                                                                            type: 'file';
                                                                                                                                                                                                                                            fileName: string;
                                                                                                                                                                                                                                            fileSize: string;
                                                                                                                                                                                                                                            } & EventMessageBase;
                                                                                                                                                                                                                                            • Message object which contains the file sent from the source. The binary data can be retrieved using Client#getMessageContent.

                                                                                                                                                                                                                                            type FlexBlockStyle

                                                                                                                                                                                                                                            type FlexBlockStyle = {
                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                            * Background color of the block. Use a hexadecimal color code.
                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                            backgroundColor?: string;
                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                            * - `true` to place a separator above the block.
                                                                                                                                                                                                                                            * - `true` will be ignored for the first block in a container because you
                                                                                                                                                                                                                                            * cannot place a separator above the first block.
                                                                                                                                                                                                                                            * - The default value is `false`.
                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                            separator?: boolean;
                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                            * Color of the separator. Use a hexadecimal color code.
                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                            separatorColor?: string;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              type FlexBox

                                                                                                                                                                                                                                              type FlexBox = {
                                                                                                                                                                                                                                              type: 'box';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * The placement style of components in this box. Specify one of the following values:
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * - `horizontal`: Components are placed horizontally. The `direction`
                                                                                                                                                                                                                                              * property of the [bubble](https://developers.line.biz/en/reference/messaging-api/#bubble)
                                                                                                                                                                                                                                              * container specifies the order.
                                                                                                                                                                                                                                              * - `vertical`: Components are placed vertically from top to bottom.
                                                                                                                                                                                                                                              * - `baseline`: Components are placed in the same way as `horizontal` is
                                                                                                                                                                                                                                              * specified except the baselines of the components are aligned.
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * For more information, see
                                                                                                                                                                                                                                              * [Types of box layouts](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#box-layout-types).
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              layout: 'horizontal' | 'vertical' | 'baseline';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Components in this box. Here are the types of components available:
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * - When the `layout` property is `horizontal` or `vertical`:
                                                                                                                                                                                                                                              * + [Box](https://developers.line.biz/en/reference/messaging-api/#box)
                                                                                                                                                                                                                                              * + [button](https://developers.line.biz/en/reference/messaging-api/#button)
                                                                                                                                                                                                                                              * + [image](https://developers.line.biz/en/reference/messaging-api/#f-image)
                                                                                                                                                                                                                                              * + [text](https://developers.line.biz/en/reference/messaging-api/#f-text)
                                                                                                                                                                                                                                              * + [separator](https://developers.line.biz/en/reference/messaging-api/#separator)
                                                                                                                                                                                                                                              * + [filler](https://developers.line.biz/en/reference/messaging-api/#filler)
                                                                                                                                                                                                                                              * + [spacer (not recommended)](https://developers.line.biz/en/reference/messaging-api/#spacer)
                                                                                                                                                                                                                                              * - When the `layout` property is `baseline`:
                                                                                                                                                                                                                                              * + [icon](https://developers.line.biz/en/reference/messaging-api/#icon)
                                                                                                                                                                                                                                              * + [text](https://developers.line.biz/en/reference/messaging-api/#f-text)
                                                                                                                                                                                                                                              * + [filler](https://developers.line.biz/en/reference/messaging-api/#filler)
                                                                                                                                                                                                                                              * + [spacer (not recommended)](https://developers.line.biz/en/reference/messaging-api/#spacer)
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              contents: FlexComponent[];
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Background color of the block. In addition to the RGB color, an alpha
                                                                                                                                                                                                                                              * channel (transparency) can also be set. Use a hexadecimal color code.
                                                                                                                                                                                                                                              * (Example:#RRGGBBAA) The default value is `#00000000`.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              backgroundColor?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Color of box border. Use a hexadecimal color code.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              borderColor?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Width of box border. You can specify a value in pixels or any one of none,
                                                                                                                                                                                                                                              * light, normal, medium, semi-bold, or bold. none does not render a border
                                                                                                                                                                                                                                              * while the others become wider in the order of listing.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              borderWidth?:
                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                              | 'none'
                                                                                                                                                                                                                                              | 'light'
                                                                                                                                                                                                                                              | 'normal'
                                                                                                                                                                                                                                              | 'medium'
                                                                                                                                                                                                                                              | 'semi-bold'
                                                                                                                                                                                                                                              | 'bold';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Radius at the time of rounding the corners of the border. You can specify a
                                                                                                                                                                                                                                              * value in pixels or any one of `none`, `xs`, `sm`, `md`, `lg`, `xl`, or `xxl`. none does not
                                                                                                                                                                                                                                              * round the corner while the others increase in radius in the order of listing. The default value is none.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              cornerRadius?: string | 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Width of the box. For more information, see [Width of a box](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#box-width) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              width?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Height of the box. For more information, see [Height of a box](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#box-height) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              height?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * The ratio of the width or height of this box within the parent box. The
                                                                                                                                                                                                                                              * default value for the horizontal parent box is `1`, and the default value
                                                                                                                                                                                                                                              * for the vertical parent box is `0`.
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * For more information, see
                                                                                                                                                                                                                                              * [Width and height of components](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-width-and-height).
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              flex?: number;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Minimum space between components in this box.
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                              * size increases in the order of listing.
                                                                                                                                                                                                                                              * - The default value is `none`.
                                                                                                                                                                                                                                              * - To override this setting for a specific component, set the `margin`
                                                                                                                                                                                                                                              * property of that component.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              spacing?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Minimum space between this box and the previous component in the parent box.
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                              * size increases in the order of listing.
                                                                                                                                                                                                                                              * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                              * box.
                                                                                                                                                                                                                                              * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                              * property will be ignored.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Free space between the borders of this box and the child element.
                                                                                                                                                                                                                                              * For more information, see [Box padding](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#padding-property) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              paddingAll?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Free space between the border at the upper end of this box and the upper end of the child element.
                                                                                                                                                                                                                                              * For more information, see [Box padding](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#padding-property) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              paddingTop?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Free space between the border at the lower end of this box and the lower end of the child element.
                                                                                                                                                                                                                                              * For more information, see [Box padding](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#padding-property) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              paddingBottom?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Free space between the border at the left end of this box and the left end of the child element.
                                                                                                                                                                                                                                              * For more information, see [Box padding](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#padding-property) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              paddingStart?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Free space between the border at the right end of this box and the right end of the child element.
                                                                                                                                                                                                                                              * For more information, see [Box padding](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#padding-property) in the API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              paddingEnd?: string;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Action performed when this button is tapped.
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * Specify an [action object](https://developers.line.biz/en/reference/messaging-api/#action-objects).
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              action?: Action;
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * How child elements are aligned along the main axis of the parent element. If the
                                                                                                                                                                                                                                              * parent element is a horizontal box, this only takes effect when its child elements have
                                                                                                                                                                                                                                              * their `flex` property set equal to 0. For more information, see [Arranging a box's child elements and free space](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#justify-property)
                                                                                                                                                                                                                                              * in the Messaging API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              justifyContent?:
                                                                                                                                                                                                                                              | 'flex-start'
                                                                                                                                                                                                                                              | 'center'
                                                                                                                                                                                                                                              | 'flex-end'
                                                                                                                                                                                                                                              | 'space-between'
                                                                                                                                                                                                                                              | 'space-around'
                                                                                                                                                                                                                                              | 'space-evenly';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * How child elements are aligned along the cross axis of the parent element. For more
                                                                                                                                                                                                                                              * information, see [Arranging a box's child elements and free space](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#justify-property) in the Messaging API documentation.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              alignItems?: 'flex-start' | 'center' | 'flex-end';
                                                                                                                                                                                                                                              background?: Background;
                                                                                                                                                                                                                                              } & Offset;
                                                                                                                                                                                                                                              • This is a component that defines the layout of child components. You can also include a box in a box.

                                                                                                                                                                                                                                              type FlexBubble

                                                                                                                                                                                                                                              type FlexBubble = {
                                                                                                                                                                                                                                              type: 'bubble';
                                                                                                                                                                                                                                              size?: 'nano' | 'micro' | 'kilo' | 'mega' | 'giga';
                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                              * Text directionality and the order of components in horizontal boxes in the
                                                                                                                                                                                                                                              * container. Specify one of the following values:
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * - `ltr`: Left to right
                                                                                                                                                                                                                                              * - `rtl`: Right to left
                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                              * The default value is `ltr`.
                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                              direction?: 'ltr' | 'rtl';
                                                                                                                                                                                                                                              header?: FlexBox;
                                                                                                                                                                                                                                              hero?: FlexBox | FlexImage;
                                                                                                                                                                                                                                              body?: FlexBox;
                                                                                                                                                                                                                                              footer?: FlexBox;
                                                                                                                                                                                                                                              styles?: FlexBubbleStyle;
                                                                                                                                                                                                                                              action?: Action;
                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                              • This is a container that contains one message bubble. It can contain four blocks: header, hero, body, and footer.

                                                                                                                                                                                                                                                For more information about using each block, see [Block](https://developers.line.biz/en/docs/messaging-api/flex-message-elements/#block).

                                                                                                                                                                                                                                              type FlexBubbleStyle

                                                                                                                                                                                                                                              type FlexBubbleStyle = {
                                                                                                                                                                                                                                              header?: FlexBlockStyle;
                                                                                                                                                                                                                                              hero?: FlexBlockStyle;
                                                                                                                                                                                                                                              body?: FlexBlockStyle;
                                                                                                                                                                                                                                              footer?: FlexBlockStyle;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                type FlexButton

                                                                                                                                                                                                                                                type FlexButton = {
                                                                                                                                                                                                                                                type: 'button';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Action performed when this button is tapped.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * Specify an [action object](https://developers.line.biz/en/reference/messaging-api/#action-objects).
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                action: Action;
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * The ratio of the width or height of this box within the parent box.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * The default value for the horizontal parent box is `1`, and the default
                                                                                                                                                                                                                                                * value for the vertical parent box is `0`.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * For more information, see
                                                                                                                                                                                                                                                * [Width and height of components](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-width-and-height).
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                flex?: number;
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Minimum space between this box and the previous component in the parent box.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                                * size increases in the order of listing.
                                                                                                                                                                                                                                                * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                                * box.
                                                                                                                                                                                                                                                * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                                * property will be ignored.
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Height of the button. The default value is `md`.
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                height?: 'sm' | 'md';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Style of the button. Specify one of the following values:
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * - `link`: HTML link style
                                                                                                                                                                                                                                                * - `primary`: Style for dark color buttons
                                                                                                                                                                                                                                                * - `secondary`: Style for light color buttons
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * The default value is `link`.
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                style?: 'link' | 'primary' | 'secondary';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Use a hexadecimal color code.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * - Character color when the `style` property is `link`.
                                                                                                                                                                                                                                                * - Background color when the `style` property is `primary` or `secondary`.
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                color?: string;
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * Vertical alignment style. Specify one of the following values:
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * - `top`: Top-aligned
                                                                                                                                                                                                                                                * - `bottom`: Bottom-aligned
                                                                                                                                                                                                                                                * - `center`: Center-aligned
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * The default value is `top`.
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * If the `layout` property of the parent box is `baseline`, the `gravity`
                                                                                                                                                                                                                                                * property will be ignored.
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                gravity?: 'top' | 'bottom' | 'center';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * The method by which to adjust the text font size. Specify this value:
                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                * - `shrink-to-fit`: Automatically shrink the font
                                                                                                                                                                                                                                                * size to fit the width of the component. This
                                                                                                                                                                                                                                                * property takes a "best-effort" approach that may
                                                                                                                                                                                                                                                * work differently—or not at all!—on some platforms.
                                                                                                                                                                                                                                                * For more information, see [Automatically shrink fonts to fit](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#adjusts-fontsize-to-fit)
                                                                                                                                                                                                                                                * in the Messaging API documentation.
                                                                                                                                                                                                                                                * - LINE 10.13.0 or later for iOS and Android
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                adjustMode?: 'shrink-to-fit';
                                                                                                                                                                                                                                                } & Offset;
                                                                                                                                                                                                                                                • This component draws a button.

                                                                                                                                                                                                                                                  When the user taps a button, a specified action is performed.

                                                                                                                                                                                                                                                type FlexCarousel

                                                                                                                                                                                                                                                type FlexCarousel = {
                                                                                                                                                                                                                                                type: 'carousel';
                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                * (Max: 12 bubbles)
                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                contents: FlexBubble[];
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  type FlexComponent

                                                                                                                                                                                                                                                  type FlexComponent =
                                                                                                                                                                                                                                                  | FlexBox
                                                                                                                                                                                                                                                  | FlexButton
                                                                                                                                                                                                                                                  | FlexImage
                                                                                                                                                                                                                                                  | FlexIcon
                                                                                                                                                                                                                                                  | FlexText
                                                                                                                                                                                                                                                  | FlexSpan
                                                                                                                                                                                                                                                  | FlexSeparator
                                                                                                                                                                                                                                                  | FlexFiller
                                                                                                                                                                                                                                                  | FlexSpacer;
                                                                                                                                                                                                                                                  • Components are objects that compose a Flex Message container. Here are the types of components available:

                                                                                                                                                                                                                                                    - [Box](https://developers.line.biz/en/reference/messaging-api/#box) - [Button](https://developers.line.biz/en/reference/messaging-api/#button) - [Image](https://developers.line.biz/en/reference/messaging-api/#f-image) - [Icon](https://developers.line.biz/en/reference/messaging-api/#icon) - [Text](https://developers.line.biz/en/reference/messaging-api/#f-text) - [Span](https://developers.line.biz/en/reference/messaging-api/#span) - [Separator](https://developers.line.biz/en/reference/messaging-api/#separator) - [Filler](https://developers.line.biz/en/reference/messaging-api/#filler) - [Spacer (not recommended)](https://developers.line.biz/en/reference/messaging-api/#spacer)

                                                                                                                                                                                                                                                    See the followings for the components' JSON data samples and usage.

                                                                                                                                                                                                                                                    - [Flex Message elements](https://developers.line.biz/en/docs/messaging-api/flex-message-elements/) - [Flex Message layout](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/)

                                                                                                                                                                                                                                                  type FlexContainer

                                                                                                                                                                                                                                                  type FlexContainer = FlexBubble | FlexCarousel;
                                                                                                                                                                                                                                                  • A container is the top-level structure of a Flex Message. Here are the types of containers available.

                                                                                                                                                                                                                                                    - [Bubble](https://developers.line.biz/en/reference/messaging-api/#bubble) - [Carousel](https://developers.line.biz/en/reference/messaging-api/#f-carousel)

                                                                                                                                                                                                                                                    See [Flex Message elements](https://developers.line.biz/en/docs/messaging-api/flex-message-elements/) for the containers' JSON data samples and usage.

                                                                                                                                                                                                                                                  type FlexFiller

                                                                                                                                                                                                                                                  type FlexFiller = {
                                                                                                                                                                                                                                                  type: 'filler';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * The ratio of the width or height of this component within the parent box. For more information, see [Width and height of components](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-width-and-height).
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  flex?: number;
                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                  • This is an invisible component to fill extra space between components.

                                                                                                                                                                                                                                                    - The filler's flex property is fixed to 1. - The spacing property of the parent box will be ignored for fillers.

                                                                                                                                                                                                                                                  type FlexIcon

                                                                                                                                                                                                                                                  type FlexIcon = {
                                                                                                                                                                                                                                                  type: 'icon';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Image URL (Max character limit: 2000)
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * Protocol: HTTPS
                                                                                                                                                                                                                                                  * Image format: JPEG or PNG
                                                                                                                                                                                                                                                  * Maximum image size: 240×240 pixels
                                                                                                                                                                                                                                                  * Maximum data size: 1 MB
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  url: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Minimum space between this box and the previous component in the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                                  * size increases in the order of listing.
                                                                                                                                                                                                                                                  * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                                  * property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Maximum size of the icon width.
                                                                                                                                                                                                                                                  * The size increases in the order of listing.
                                                                                                                                                                                                                                                  * The default value is `md`.
                                                                                                                                                                                                                                                  * For more information, see [Icon, text, and span size](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#other-component-size) in the Messaging API documentation.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  size?:
                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                  | 'xxs'
                                                                                                                                                                                                                                                  | 'xs'
                                                                                                                                                                                                                                                  | 'sm'
                                                                                                                                                                                                                                                  | 'md'
                                                                                                                                                                                                                                                  | 'lg'
                                                                                                                                                                                                                                                  | 'xl'
                                                                                                                                                                                                                                                  | 'xxl'
                                                                                                                                                                                                                                                  | '3xl'
                                                                                                                                                                                                                                                  | '4xl'
                                                                                                                                                                                                                                                  | '5xl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Aspect ratio of the icon. `{width}:{height}` format.
                                                                                                                                                                                                                                                  * The values of `{width}` and `{height}` must be in the range 1–100000.
                                                                                                                                                                                                                                                  * `{height}` can't be more than three times the value of `{width}`.
                                                                                                                                                                                                                                                  * The default value is `1:1`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  aspectRatio?: string;
                                                                                                                                                                                                                                                  } & Offset;
                                                                                                                                                                                                                                                  • This component draws an icon.

                                                                                                                                                                                                                                                  type FlexImage

                                                                                                                                                                                                                                                  type FlexImage = {
                                                                                                                                                                                                                                                  type: 'image';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Image URL (Max character limit: 2000)
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - Protocol: HTTPS
                                                                                                                                                                                                                                                  * - Image format: JPEG or PNG
                                                                                                                                                                                                                                                  * - Maximum image size: 1024×1024 pixels
                                                                                                                                                                                                                                                  * - Maximum data size: 1 MB
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  url: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * The ratio of the width or height of this box within the parent box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value for the horizontal parent box is `1`, and the default
                                                                                                                                                                                                                                                  * value for the vertical parent box is `0`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - For more information, see
                                                                                                                                                                                                                                                  * [Width and height of components](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-width-and-height).
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  flex?: number;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Minimum space between this box and the previous component in the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                                  * size increases in the order of listing.
                                                                                                                                                                                                                                                  * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                                  * property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Horizontal alignment style. Specify one of the following values:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `start`: Left-aligned
                                                                                                                                                                                                                                                  * - `end`: Right-aligned
                                                                                                                                                                                                                                                  * - `center`: Center-aligned
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `center`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  align?: 'start' | 'end' | 'center';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Vertical alignment style. Specify one of the following values:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `top`: Top-aligned
                                                                                                                                                                                                                                                  * - `bottom`: Bottom-aligned
                                                                                                                                                                                                                                                  * - `center`: Center-aligned
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `top`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * If the `layout` property of the parent box is `baseline`, the `gravity` property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  gravity?: 'top' | 'bottom' | 'center';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Maximum size of the image width.
                                                                                                                                                                                                                                                  * The size increases in the order of listing.
                                                                                                                                                                                                                                                  * The default value is `md`.
                                                                                                                                                                                                                                                  * For more information, see [Image size](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#image-size) in the Messaging API documentation.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  size?:
                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                  | 'xxs'
                                                                                                                                                                                                                                                  | 'xs'
                                                                                                                                                                                                                                                  | 'sm'
                                                                                                                                                                                                                                                  | 'md'
                                                                                                                                                                                                                                                  | 'lg'
                                                                                                                                                                                                                                                  | 'xl'
                                                                                                                                                                                                                                                  | 'xxl'
                                                                                                                                                                                                                                                  | '3xl'
                                                                                                                                                                                                                                                  | '4xl'
                                                                                                                                                                                                                                                  | '5xl'
                                                                                                                                                                                                                                                  | 'full';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Aspect ratio of the image. `{width}:{height}` format.
                                                                                                                                                                                                                                                  * Specify the value of `{width}` and `{height}` in the range from 1 to 100000. However,
                                                                                                                                                                                                                                                  * you cannot set `{height}` to a value that is more than three times the value of `{width}`.
                                                                                                                                                                                                                                                  * The default value is `1:1`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  aspectRatio?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Style of the image. Specify one of the following values:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `cover`: The image fills the entire drawing area. Parts of the image
                                                                                                                                                                                                                                                  * that do not fit in the drawing area are not displayed.
                                                                                                                                                                                                                                                  * - `fit`: The entire image is displayed in the drawing area. The background
                                                                                                                                                                                                                                                  * is displayed in the unused areas to the left and right of vertical images
                                                                                                                                                                                                                                                  * and in the areas above and below horizontal images.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `fit`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  aspectMode?: 'cover' | 'fit';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Background color of the image. Use a hexadecimal color code.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  backgroundColor?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Action performed when this button is tapped.
                                                                                                                                                                                                                                                  * Specify an [action object](https://developers.line.biz/en/reference/messaging-api/#action-objects).
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  action?: Action;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * When this is `true`, an animated image (APNG) plays.
                                                                                                                                                                                                                                                  * You can specify a value of `true` up to three times in a single message.
                                                                                                                                                                                                                                                  * You can't send messages that exceed this limit.
                                                                                                                                                                                                                                                  * This is `false` by default.
                                                                                                                                                                                                                                                  * Animated images larger than 300 KB aren't played back.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  animated?: Boolean;
                                                                                                                                                                                                                                                  } & Offset;
                                                                                                                                                                                                                                                  • This component draws an image.

                                                                                                                                                                                                                                                  type FlexMessage

                                                                                                                                                                                                                                                  type FlexMessage = MessageCommon & {
                                                                                                                                                                                                                                                  type: 'flex';
                                                                                                                                                                                                                                                  altText: string;
                                                                                                                                                                                                                                                  contents: FlexContainer;
                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                  • Flex Messages are messages with a customizable layout. You can customize the layout freely by combining multiple elements. For more information, see [Using Flex Messages](https://developers.line.biz/en/docs/messaging-api/using-flex-messages/).

                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                    • [Flex messages](https://developers.line.biz/en/reference/messaging-api/#flex-message)

                                                                                                                                                                                                                                                  type FlexSeparator

                                                                                                                                                                                                                                                  type FlexSeparator = {
                                                                                                                                                                                                                                                  type: 'separator';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Minimum space between this box and the previous component in the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                                  * size increases in the order of listing.
                                                                                                                                                                                                                                                  * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                                  * property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Color of the separator. Use a hexadecimal color code.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  color?: string;
                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                  • This component draws a separator between components in the parent box.

                                                                                                                                                                                                                                                  type FlexSpacer

                                                                                                                                                                                                                                                  type FlexSpacer = {
                                                                                                                                                                                                                                                  type: 'spacer';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Size of the space.
                                                                                                                                                                                                                                                  * The size increases in the order of listing.
                                                                                                                                                                                                                                                  * The default value is `md`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                  • This is an invisible component that places a fixed-size space at the beginning or end of the box.

                                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                                  type FlexSpan

                                                                                                                                                                                                                                                  type FlexSpan = {
                                                                                                                                                                                                                                                  type: 'span';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Text. If the `wrap` property of the parent text is set to `true`, you can use a new line character (`\n`) to begin on a new line.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  text: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font color. Use a hexadecimal color code.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  color?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font size. You can specify one of the following values: `xxs`, `xs`, `sm`, `md`, `lg`, `xl`, `xxl`, `3xl`, `4xl`, or `5xl`. The size increases in the order of listing. The default value is `md`.
                                                                                                                                                                                                                                                  * For more information, see [Icon, text, and span size](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#other-component-size) in the Messaging API documentation.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  size?:
                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                  | 'xxs'
                                                                                                                                                                                                                                                  | 'xs'
                                                                                                                                                                                                                                                  | 'sm'
                                                                                                                                                                                                                                                  | 'md'
                                                                                                                                                                                                                                                  | 'lg'
                                                                                                                                                                                                                                                  | 'xl'
                                                                                                                                                                                                                                                  | 'xxl'
                                                                                                                                                                                                                                                  | '3xl'
                                                                                                                                                                                                                                                  | '4xl'
                                                                                                                                                                                                                                                  | '5xl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font weight. You can specify one of the following values: `regular` or `bold`. Specifying `bold` makes the font bold. The default value is `regular`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  weight?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Style of the text. Specify one of the following values:
                                                                                                                                                                                                                                                  * - `normal`: Normal
                                                                                                                                                                                                                                                  * - `italic`: Italic
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `normal`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  style?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Decoration of the text. Specify one of the following values:
                                                                                                                                                                                                                                                  * `none`: No decoration
                                                                                                                                                                                                                                                  * `underline`: Underline
                                                                                                                                                                                                                                                  * `line-through`: Strikethrough
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `none`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * Note: The decoration set in the `decoration` property of the [text](https://developers.line.biz/en/reference/messaging-api/#f-text) cannot be overwritten by the `decoration` property of the span.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  decoration?: string;
                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                  • This component renders multiple text strings with different designs in one row. You can specify the color, size, weight, and decoration for the font. Span is set to contents property in [Text](https://developers.line.biz/en/reference/messaging-api/#f-text).

                                                                                                                                                                                                                                                  type FlexText

                                                                                                                                                                                                                                                  type FlexText = {
                                                                                                                                                                                                                                                  type: 'text';
                                                                                                                                                                                                                                                  text: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Array of spans. Be sure to set either one of the `text` property or `contents` property. If you set the `contents` property, `text` is ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  contents?: FlexSpan[];
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * The method by which to adjust the text font size. Specify this value:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `shrink-to-fit`: Automatically shrink the font
                                                                                                                                                                                                                                                  * size to fit the width of the component. This
                                                                                                                                                                                                                                                  * property takes a "best-effort" approach that may
                                                                                                                                                                                                                                                  * work differently—or not at all!—on some platforms.
                                                                                                                                                                                                                                                  * For more information, see [Automatically shrink fonts to fit](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#adjusts-fontsize-to-fit)
                                                                                                                                                                                                                                                  * in the Messaging API documentation.
                                                                                                                                                                                                                                                  * - LINE 10.13.0 or later for iOS and Android
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  adjustMode?: 'shrink-to-fit';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * The ratio of the width or height of this box within the parent box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value for the horizontal parent box is `1`, and the default
                                                                                                                                                                                                                                                  * value for the vertical parent box is `0`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * For more information, see
                                                                                                                                                                                                                                                  * [Width and height of components](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-width-and-height).
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  flex?: number;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Minimum space between this box and the previous component in the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `none` does not set a space while the other values set a space whose
                                                                                                                                                                                                                                                  * size increases in the order of listing.
                                                                                                                                                                                                                                                  * - The default value is the value of the `spacing` property of the parent
                                                                                                                                                                                                                                                  * box.
                                                                                                                                                                                                                                                  * - If this box is the first component in the parent box, the `margin`
                                                                                                                                                                                                                                                  * property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  margin?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font size.
                                                                                                                                                                                                                                                  * The size increases in the order of listing.
                                                                                                                                                                                                                                                  * The default value is `md`.
                                                                                                                                                                                                                                                  * For more information, see [Icon, text, and span size](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#other-component-size) in the Messaging API documentation.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  size?:
                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                  | 'xxs'
                                                                                                                                                                                                                                                  | 'xs'
                                                                                                                                                                                                                                                  | 'sm'
                                                                                                                                                                                                                                                  | 'md'
                                                                                                                                                                                                                                                  | 'lg'
                                                                                                                                                                                                                                                  | 'xl'
                                                                                                                                                                                                                                                  | 'xxl'
                                                                                                                                                                                                                                                  | '3xl'
                                                                                                                                                                                                                                                  | '4xl'
                                                                                                                                                                                                                                                  | '5xl';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Horizontal alignment style. Specify one of the following values:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `start`: Left-aligned
                                                                                                                                                                                                                                                  * - `end`: Right-aligned
                                                                                                                                                                                                                                                  * - `center`: Center-aligned
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `start`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  align?: 'start' | 'end' | 'center';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Vertical alignment style. Specify one of the following values:
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * - `top`: Top-aligned
                                                                                                                                                                                                                                                  * - `bottom`: Bottom-aligned
                                                                                                                                                                                                                                                  * - `center`: Center-aligned
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `top`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * If the `layout` property of the parent box is `baseline`, the `gravity`
                                                                                                                                                                                                                                                  * property will be ignored.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  gravity?: 'top' | 'bottom' | 'center';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * `true` to wrap text.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `false`.
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * If set to `true`, you can use a new line character (\n) to begin on a new
                                                                                                                                                                                                                                                  * line.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  wrap?: boolean;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Max number of lines. If the text does not fit in the specified number of
                                                                                                                                                                                                                                                  * lines, an ellipsis (…) is displayed at the end of the last line. If set to
                                                                                                                                                                                                                                                  * 0, all the text is displayed. The default value is 0.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  maxLines?: number;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font weight.
                                                                                                                                                                                                                                                  * Specifying `bold`makes the font bold.
                                                                                                                                                                                                                                                  * The default value is `regular`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  weight?: 'regular' | 'bold';
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Font color. Use a hexadecimal color code.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  color?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Action performed when this text is tapped.
                                                                                                                                                                                                                                                  * Specify an [action object](https://developers.line.biz/en/reference/messaging-api/#action-objects).
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  action?: Action;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Style of the text. Specify one of the following values:
                                                                                                                                                                                                                                                  * - `normal`: Normal
                                                                                                                                                                                                                                                  * - `italic`: Italic
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `normal`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  style?: string;
                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                  * Decoration of the text. Specify one of the following values:
                                                                                                                                                                                                                                                  * `none`: No decoration
                                                                                                                                                                                                                                                  * `underline`: Underline
                                                                                                                                                                                                                                                  * `line-through`: Strikethrough
                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                  * The default value is `none`.
                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                  decoration?: string;
                                                                                                                                                                                                                                                  } & Offset;

                                                                                                                                                                                                                                                    type FollowEvent

                                                                                                                                                                                                                                                    type FollowEvent = {
                                                                                                                                                                                                                                                    type: 'follow';
                                                                                                                                                                                                                                                    } & ReplyableEvent;
                                                                                                                                                                                                                                                    • Event object for when your account is added as a friend (or unblocked).

                                                                                                                                                                                                                                                    type FriendDemographics

                                                                                                                                                                                                                                                    type FriendDemographics = {
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * `true` if friend demographic information is available.
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    available: boolean;
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Percentage per gender
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    genders?: Array<
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Gender
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    gender: 'unknown' | 'male' | 'female';
                                                                                                                                                                                                                                                    } & PercentageAble
                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Percentage per age group
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    ages?: Array<
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Age group
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    age: string;
                                                                                                                                                                                                                                                    } & PercentageAble
                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Percentage per area
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    areas?: Array<
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                    area: string;
                                                                                                                                                                                                                                                    } & PercentageAble
                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Percentage by OS
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    appTypes?: Array<
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                    appType: 'ios' | 'android' | 'others';
                                                                                                                                                                                                                                                    } & PercentageAble
                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Percentage per friendship duration
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    subscriptionPeriods?: Array<
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                    * Friendship duration
                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                    subscriptionPeriod:
                                                                                                                                                                                                                                                    | 'over365days'
                                                                                                                                                                                                                                                    | 'within365days'
                                                                                                                                                                                                                                                    | 'within180days'
                                                                                                                                                                                                                                                    | 'within90days'
                                                                                                                                                                                                                                                    | 'within30days'
                                                                                                                                                                                                                                                    | 'within7days'
                                                                                                                                                                                                                                                    | 'unknown';
                                                                                                                                                                                                                                                    } & PercentageAble
                                                                                                                                                                                                                                                    >;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      type GetRichMenuAliasListResponse

                                                                                                                                                                                                                                                      type GetRichMenuAliasListResponse = {
                                                                                                                                                                                                                                                      aliases: GetRichMenuAliasResponse[];
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        type GetRichMenuAliasResponse

                                                                                                                                                                                                                                                        type GetRichMenuAliasResponse = {
                                                                                                                                                                                                                                                        richMenuAliasId: string;
                                                                                                                                                                                                                                                        richMenuId: string;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          type Group

                                                                                                                                                                                                                                                          type Group = {
                                                                                                                                                                                                                                                          type: 'group';
                                                                                                                                                                                                                                                          groupId: string;
                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                          * ID of the source user.
                                                                                                                                                                                                                                                          *
                                                                                                                                                                                                                                                          * Only included in [message events](https://developers.line.biz/en/reference/messaging-api/#message-event).
                                                                                                                                                                                                                                                          * Not included if the user has not agreed to the
                                                                                                                                                                                                                                                          * [Official Accounts Terms of Use](https://developers.line.biz/en/docs/messaging-api/user-consent/).
                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                          userId?: string;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            type GroupSummaryResponse

                                                                                                                                                                                                                                                            type GroupSummaryResponse = {
                                                                                                                                                                                                                                                            groupId: string;
                                                                                                                                                                                                                                                            groupName: string;
                                                                                                                                                                                                                                                            pictureUrl: string;
                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                            • Response body of get group summary.

                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                              • [Get group summary](https://developers.line.biz/ja/reference/messaging-api/#get-group-summary)

                                                                                                                                                                                                                                                            type ImageEventMessage

                                                                                                                                                                                                                                                            type ImageEventMessage = {
                                                                                                                                                                                                                                                            type: 'image';
                                                                                                                                                                                                                                                            contentProvider: ContentProvider;
                                                                                                                                                                                                                                                            } & EventMessageBase;
                                                                                                                                                                                                                                                            • Message object which contains the image content sent from the source. The binary image data can be retrieved using Client#getMessageContent.

                                                                                                                                                                                                                                                            type ImageMapAction

                                                                                                                                                                                                                                                            type ImageMapAction = ImageMapURIAction | ImageMapMessageAction;
                                                                                                                                                                                                                                                            • Object which specifies the actions and tappable regions of an imagemap.

                                                                                                                                                                                                                                                              When a region is tapped, the user is redirected to the URI specified in uri and the message specified in message is sent.

                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                              • [Imagemap action objects](https://developers.line.biz/en/reference/messaging-api/#imagemap-action-objects)

                                                                                                                                                                                                                                                            type ImageMapActionBase

                                                                                                                                                                                                                                                            type ImageMapActionBase = {
                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                            * Spoken when the accessibility feature is enabled on the client device. (Max: 50 characters)
                                                                                                                                                                                                                                                            * Supported on LINE 8.2.0 and later for iOS.
                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                            label?: string;
                                                                                                                                                                                                                                                            /** Defined tappable area */
                                                                                                                                                                                                                                                            area: Area;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              type ImageMapMessage

                                                                                                                                                                                                                                                              type ImageMapMessage = MessageCommon & {
                                                                                                                                                                                                                                                              type: 'imagemap';
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * [Base URL](https://developers.line.biz/en/reference/messaging-api/#base-url) of image
                                                                                                                                                                                                                                                              * (Max: 2000 characters, **HTTPS**)
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              baseUrl: string;
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * Alternative text (Max: 400 characters)
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              altText: string;
                                                                                                                                                                                                                                                              baseSize: Size;
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * Video to play inside a image map messages
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              video?: {
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * URL of video file (Max: 2000 characters)
                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                              * - **HTTPS**
                                                                                                                                                                                                                                                              * - mp4
                                                                                                                                                                                                                                                              * - Max: 1 minute
                                                                                                                                                                                                                                                              * - Max: 10 MB
                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                              * A very wide or tall video may be cropped when played in some environments.
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              originalContentUrl: string;
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * URL of preview image (Max: 2000 characters)
                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                              * - **HTTPS**
                                                                                                                                                                                                                                                              * - JPEG
                                                                                                                                                                                                                                                              * - Max: 240 x 240
                                                                                                                                                                                                                                                              * - Max: 1 MB
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              previewImageUrl: string;
                                                                                                                                                                                                                                                              area: Area;
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * External link to be displayed after a video is played
                                                                                                                                                                                                                                                              * This property is required if you set a video to play and a label to display after the video on the imagemap
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              externalLink?: {
                                                                                                                                                                                                                                                              linkUri: string;
                                                                                                                                                                                                                                                              label: string;
                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * Action when tapped (Max: 50)
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              actions: ImageMapAction[];
                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                                • [Imagemap message](https://developers.line.biz/en/reference/messaging-api/#imagemap-message)

                                                                                                                                                                                                                                                              type ImageMapMessageAction

                                                                                                                                                                                                                                                              type ImageMapMessageAction = {
                                                                                                                                                                                                                                                              type: 'message';
                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                              * Message to send (Max: 400 characters)
                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                              text: string;
                                                                                                                                                                                                                                                              } & ImageMapActionBase;

                                                                                                                                                                                                                                                                type ImageMapURIAction

                                                                                                                                                                                                                                                                type ImageMapURIAction = {
                                                                                                                                                                                                                                                                type: 'uri';
                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                * Webpage URL (Max: 1000 characters)
                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                linkUri: string;
                                                                                                                                                                                                                                                                } & ImageMapActionBase;

                                                                                                                                                                                                                                                                  type ImageMessage

                                                                                                                                                                                                                                                                  type ImageMessage = MessageCommon & {
                                                                                                                                                                                                                                                                  type: 'image';
                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                  * Image URL (Max: 2000 characters)
                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                  * - **HTTPS**
                                                                                                                                                                                                                                                                  * - JPEG
                                                                                                                                                                                                                                                                  * - Max: 1024 x 1024
                                                                                                                                                                                                                                                                  * - Max: 1 MB
                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                  originalContentUrl: string;
                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                  * Preview image URL (Max: 2000 characters)
                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                  * - **HTTPS**
                                                                                                                                                                                                                                                                  * - JPEG
                                                                                                                                                                                                                                                                  * - Max: 240 x 240
                                                                                                                                                                                                                                                                  * - Max: 1 MB
                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                  previewImageUrl: string;
                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                    • [Image message](https://developers.line.biz/en/reference/messaging-api/#image-message)

                                                                                                                                                                                                                                                                  type InsightStatisticsResponse

                                                                                                                                                                                                                                                                  type InsightStatisticsResponse = {
                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                  * Calculation status. One of:
                                                                                                                                                                                                                                                                  * - `ready`: Calculation has finished; the numbers are up-to-date.
                                                                                                                                                                                                                                                                  * - `unready`: We haven't finished calculating the number of sent messages for the specified `date`. Calculation usually takes about a day. Please try again later.
                                                                                                                                                                                                                                                                  * - `out_of_service`: The specified `date` is earlier than the date on which we first started calculating sent messages. Different APIs have different date. Check them at the [document](https://developers.line.biz/en/reference/messaging-api/).
                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                  status: 'ready' | 'unready' | 'out_of_service';
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    type JoinEvent

                                                                                                                                                                                                                                                                    type JoinEvent = {
                                                                                                                                                                                                                                                                    type: 'join';
                                                                                                                                                                                                                                                                    } & ReplyableEvent;
                                                                                                                                                                                                                                                                    • Event object for when your bot joins a group or room. You can reply to join events.

                                                                                                                                                                                                                                                                      A join event is triggered at different times for groups and rooms.

                                                                                                                                                                                                                                                                      - For groups: A join event is sent when a user invites your bot. - For rooms: A join event is sent when the first event (for example when a user sends a message or is added to the room) occurs after your bot is added.

                                                                                                                                                                                                                                                                    type LeaveEvent

                                                                                                                                                                                                                                                                    type LeaveEvent = {
                                                                                                                                                                                                                                                                    type: 'leave';
                                                                                                                                                                                                                                                                    } & EventBase;
                                                                                                                                                                                                                                                                    • Event object for when a user removes your bot from a group or a room.

                                                                                                                                                                                                                                                                    type LINEThingsActionResult

                                                                                                                                                                                                                                                                    type LINEThingsActionResult = {
                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                    * `void`, `binary`
                                                                                                                                                                                                                                                                    * Depends on `type` of the executed action.
                                                                                                                                                                                                                                                                    * This property is always included if `things.actionResults` is not empty.
                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                    type: 'void' | 'binary';
                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                    * Base64-encoded binary data
                                                                                                                                                                                                                                                                    * This property is always included when `things.actionResults[].type` is `binary`.
                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                    data?: string;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      type LINEThingsScenarioExecutionEvent

                                                                                                                                                                                                                                                                      type LINEThingsScenarioExecutionEvent = ReplyableEvent & {
                                                                                                                                                                                                                                                                      type: 'things';
                                                                                                                                                                                                                                                                      things: {
                                                                                                                                                                                                                                                                      type: 'scenarioResult';
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Device ID of the device that executed the scenario
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      deviceId: string;
                                                                                                                                                                                                                                                                      result: {
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Scenario ID executed
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      scenarioId: string;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Revision number of the scenario set containing the executed scenario
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      revision: number;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Timestamp for when execution of scenario action started (milliseconds, LINE app time)
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      startTime: number;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Timestamp for when execution of scenario was completed (milliseconds, LINE app time)
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      endtime: number;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Scenario execution completion status
                                                                                                                                                                                                                                                                      * See also [things.resultCode definitions](https://developers.line.biz/en/reference/messaging-api/#things-resultcode).
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      resultCode: 'success' | 'gatt_error' | 'runtime_error';
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Execution result of individual operations specified in action
                                                                                                                                                                                                                                                                      * Note that an array of actions specified in a scenario has the following characteristics
                                                                                                                                                                                                                                                                      * - The actions defined in a scenario are performed sequentially, from top to bottom.
                                                                                                                                                                                                                                                                      * - Each action produces some result when executed.
                                                                                                                                                                                                                                                                      * Even actions that do not generate data, such as `SLEEP`, return an execution result of type `void`.
                                                                                                                                                                                                                                                                      * The number of items in an action array may be 0.
                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                      * Therefore, things.actionResults has the following properties:
                                                                                                                                                                                                                                                                      * - The number of items in the array matches the number of actions defined in the scenario.
                                                                                                                                                                                                                                                                      * - The order of execution results matches the order in which actions are performed.
                                                                                                                                                                                                                                                                      * That is, in a scenario set with multiple `GATT_READ` actions,
                                                                                                                                                                                                                                                                      * the results are returned in the order in which each individual `GATT_READ` action was performed.
                                                                                                                                                                                                                                                                      * - If 0 actions are defined in the scenario, the number of items in things.actionResults will be 0.
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      actionResults: Array<LINEThingsActionResult>;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Data contained in notification
                                                                                                                                                                                                                                                                      * The value is Base64-encoded binary data.
                                                                                                                                                                                                                                                                      * Only included for scenarios where `trigger.type = BLE_NOTIFICATION`.
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      bleNotificationPayload?: string;
                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                      * Error reason
                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                      errorReason?: string;
                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        type LocationEventMessage

                                                                                                                                                                                                                                                                        type LocationEventMessage = {
                                                                                                                                                                                                                                                                        type: 'location';
                                                                                                                                                                                                                                                                        title: string;
                                                                                                                                                                                                                                                                        address: string;
                                                                                                                                                                                                                                                                        latitude: number;
                                                                                                                                                                                                                                                                        longitude: number;
                                                                                                                                                                                                                                                                        } & EventMessageBase;
                                                                                                                                                                                                                                                                        • Message object which contains the location data sent from the source.

                                                                                                                                                                                                                                                                        type LocationMessage

                                                                                                                                                                                                                                                                        type LocationMessage = MessageCommon & {
                                                                                                                                                                                                                                                                        type: 'location';
                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                        * Title (Max: 100 characters)
                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                        title: string;
                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                        * Address (Max: 100 characters)
                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                        address: string;
                                                                                                                                                                                                                                                                        latitude: number;
                                                                                                                                                                                                                                                                        longitude: number;
                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                        • See Also

                                                                                                                                                                                                                                                                          • [Location message](https://developers.line.biz/en/reference/messaging-api/#location-message)

                                                                                                                                                                                                                                                                        type MemberJoinEvent

                                                                                                                                                                                                                                                                        type MemberJoinEvent = {
                                                                                                                                                                                                                                                                        type: 'memberJoined';
                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                        * User ID of users who joined
                                                                                                                                                                                                                                                                        * Array of [source user](https://developers.line.biz/en/reference/messaging-api/#source-user) objects
                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                        joined: {
                                                                                                                                                                                                                                                                        members: Array<User>;
                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                        } & ReplyableEvent;
                                                                                                                                                                                                                                                                        • Event object for when a user joins a [group](https://developers.line.biz/en/docs/messaging-api/group-chats/#group) or [room](https://developers.line.biz/en/docs/messaging-api/group-chats/#room) that the bot is in.

                                                                                                                                                                                                                                                                        type MemberLeaveEvent

                                                                                                                                                                                                                                                                        type MemberLeaveEvent = {
                                                                                                                                                                                                                                                                        type: 'memberLeft';
                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                        * User ID of users who left
                                                                                                                                                                                                                                                                        * Array of [source user](https://developers.line.biz/en/reference/messaging-api/#source-user) objects
                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                        left: {
                                                                                                                                                                                                                                                                        members: Array<User>;
                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                        } & EventBase;
                                                                                                                                                                                                                                                                        • Event object for when a user leaves a [group](https://developers.line.biz/en/docs/messaging-api/group-chats/#group) or [room](https://developers.line.biz/en/docs/messaging-api/group-chats/#room) that the bot is in.

                                                                                                                                                                                                                                                                        type MembersCountResponse

                                                                                                                                                                                                                                                                        type MembersCountResponse = {
                                                                                                                                                                                                                                                                        count: number;
                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                        • Response body of get members in group count and get members in room count.

                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                          • [Get members in group count](https://developers.line.biz/en/reference/messaging-api/#get-members-group-count)

                                                                                                                                                                                                                                                                          • [Get members in room count](https://developers.line.biz/en/reference/messaging-api/#get-members-room-count)

                                                                                                                                                                                                                                                                        type Message

                                                                                                                                                                                                                                                                        type Message =
                                                                                                                                                                                                                                                                        | TextMessage
                                                                                                                                                                                                                                                                        | ImageMessage
                                                                                                                                                                                                                                                                        | VideoMessage
                                                                                                                                                                                                                                                                        | AudioMessage
                                                                                                                                                                                                                                                                        | LocationMessage
                                                                                                                                                                                                                                                                        | StickerMessage
                                                                                                                                                                                                                                                                        | ImageMapMessage
                                                                                                                                                                                                                                                                        | TemplateMessage
                                                                                                                                                                                                                                                                        | FlexMessage;
                                                                                                                                                                                                                                                                        • JSON object which contains the contents of the message you send.

                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                          • [Message objects](https://developers.line.biz/en/reference/messaging-api/#message-objects)

                                                                                                                                                                                                                                                                        type MessageAction

                                                                                                                                                                                                                                                                        type MessageAction = {
                                                                                                                                                                                                                                                                        type: 'message';
                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                        * Text sent when the action is performed (Max: 300 characters)
                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                        text: string;
                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                        • When a control associated with this action is tapped, the string in the text property is sent as a message from the user.

                                                                                                                                                                                                                                                                        type MessageAPIResponseBase

                                                                                                                                                                                                                                                                        type MessageAPIResponseBase = {
                                                                                                                                                                                                                                                                        [LINE_REQUEST_ID_HTTP_HEADER_NAME]?: string;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          type MessageCommon

                                                                                                                                                                                                                                                                          type MessageCommon = {
                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                          * For the quick reply feature.
                                                                                                                                                                                                                                                                          * For more information, see [Using quick replies](https://developers.line.biz/en/docs/messaging-api/using-quick-reply/).
                                                                                                                                                                                                                                                                          *
                                                                                                                                                                                                                                                                          * If the user receives multiple
                                                                                                                                                                                                                                                                          * [message objects](https://developers.line.biz/en/reference/messaging-api/#message-objects),
                                                                                                                                                                                                                                                                          * the quickReply property of the last message object is displayed.
                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                          quickReply?: QuickReply;
                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                          * [Change icon and display name](https://developers.line.biz/en/docs/messaging-api/icon-nickname-switch/)
                                                                                                                                                                                                                                                                          *
                                                                                                                                                                                                                                                                          * When sending a message from the LINE Official Account, you can specify the `sender.name` and the `sender.iconUrl` properties in [Message objects](https://developers.line.biz/en/reference/messaging-api/#message-objects).
                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                          sender?: Sender;
                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                          • See Also

                                                                                                                                                                                                                                                                            • [Common properties for messages](https://developers.line.biz/en/reference/messaging-api/#common-properties-for-messages)

                                                                                                                                                                                                                                                                          type MessageEvent

                                                                                                                                                                                                                                                                          type MessageEvent = {
                                                                                                                                                                                                                                                                          type: 'message';
                                                                                                                                                                                                                                                                          message: EventMessage;
                                                                                                                                                                                                                                                                          } & ReplyableEvent;
                                                                                                                                                                                                                                                                          • Webhook event object which contains the sent message.

                                                                                                                                                                                                                                                                            The message property contains a message object which corresponds with the message type. You can reply to message events.

                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                            • [Message event](https://developers.line.biz/en/reference/messaging-api/#message-event)

                                                                                                                                                                                                                                                                          type NarrowcastProgressResponse

                                                                                                                                                                                                                                                                          type NarrowcastProgressResponse = (
                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                          phase: 'waiting';
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                          | ((
                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                          phase: 'sending' | 'succeeded';
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                          phase: 'failed';
                                                                                                                                                                                                                                                                          failedDescription: string;
                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                          ) & {
                                                                                                                                                                                                                                                                          successCount: number;
                                                                                                                                                                                                                                                                          failureCount: number;
                                                                                                                                                                                                                                                                          targetCount: string;
                                                                                                                                                                                                                                                                          acceptedTime: string;
                                                                                                                                                                                                                                                                          completedTime: string;
                                                                                                                                                                                                                                                                          })
                                                                                                                                                                                                                                                                          ) & {
                                                                                                                                                                                                                                                                          errorCode?: 1 | 2;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            type NumberOfFollowers

                                                                                                                                                                                                                                                                            type NumberOfFollowers = InsightStatisticsResponse & {
                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                            * The number of times, as of the specified `date`, that a user added this LINE official account as a friend. The number doesn't decrease when a user blocks the account after adding it, or when they delete their own account.
                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                            followers: Number;
                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                            * The number of users, as of the specified `date`, that the official account can reach with messages targeted by gender, age, or area. This number includes users for whom we estimated demographic attributes based on their activity in LINE and LINE-connected services.
                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                            targetedReaches: Number;
                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                            * The number of users blocking the account as of the specified `date`. The number decreases when a user unblocks the account.
                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                            blocks: Number;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              type NumberOfFollowersResponse

                                                                                                                                                                                                                                                                              type NumberOfFollowersResponse = InsightStatisticsResponse | NumberOfFollowers;

                                                                                                                                                                                                                                                                                type NumberOfMessageDeliveries

                                                                                                                                                                                                                                                                                type NumberOfMessageDeliveries = InsightStatisticsResponse & {
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of push messages sent to **all** of this LINE official account's friends (broadcast messages).
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                broadcast: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of push messages sent to **some** of this LINE official account's friends, based on specific attributes (targeted/segmented messages).
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                targeting: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of auto-response messages sent.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                autoResponse: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of greeting messages sent.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                welcomeResponse: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of messages sent from LINE Official Account Manager [Chat screen](https://www.linebiz.com/jp-en/manual/OfficialAccountManager/chats/screens/).
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                chat: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of broadcast messages sent with the [Send broadcast message](https://developers.line.biz/en/reference/messaging-api/#send-broadcast-message) Messaging API operation.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                apiBroadcast: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of push messages sent with the [Send push message](https://developers.line.biz/en/reference/messaging-api/#send-push-message) Messaging API operation.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                apiPush: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of multicast messages sent with the [Send multicast message](https://developers.line.biz/en/reference/messaging-api/#send-multicast-message) Messaging API operation.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                apiMulticast: number;
                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                * Number of replies sent with the [Send reply message](https://developers.line.biz/en/reference/messaging-api/#send-reply-message) Messaging API operation.
                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                apiReply: number;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  type NumberOfMessageDeliveriesResponse

                                                                                                                                                                                                                                                                                  type NumberOfMessageDeliveriesResponse =
                                                                                                                                                                                                                                                                                  | InsightStatisticsResponse
                                                                                                                                                                                                                                                                                  | NumberOfMessageDeliveries;

                                                                                                                                                                                                                                                                                    type NumberOfMessagesSentResponse

                                                                                                                                                                                                                                                                                    type NumberOfMessagesSentResponse = InsightStatisticsResponse & {
                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                    * The number of messages sent with the Messaging API on the date specified in date.
                                                                                                                                                                                                                                                                                    * The response has this property only when the value of status is `ready`.
                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                    success?: number;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      type NumberOfMessagesSentThisMonth

                                                                                                                                                                                                                                                                                      type NumberOfMessagesSentThisMonth = {
                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                      * The number of sent messages in the current month
                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                      totalUsage: number;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        type Offset

                                                                                                                                                                                                                                                                                        type Offset = {
                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                        * Reference position for placing this box. Specify one of the following values:
                                                                                                                                                                                                                                                                                        * - `relative`: Use the previous box as reference.
                                                                                                                                                                                                                                                                                        * - `absolute`: Use the top left of parent element as reference.
                                                                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                                                                        * The default value is relative.
                                                                                                                                                                                                                                                                                        * For more information, see [Offset](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-offset) in the API documentation.
                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                        position?: 'relative' | 'absolute';
                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                        * The top offset.
                                                                                                                                                                                                                                                                                        * For more information, see [Offset](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-offset) in the API documentation.
                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                        offsetTop?: string;
                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                        * The bottom offset.
                                                                                                                                                                                                                                                                                        * For more information, see [Offset](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-offset) in the API documentation.
                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                        offsetBottom?: string;
                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                        * The left offset.
                                                                                                                                                                                                                                                                                        * For more information, see [Offset](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-offset) in the API documentation.
                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                        offsetStart?: string;
                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                        * The right offset.
                                                                                                                                                                                                                                                                                        * For more information, see [Offset](https://developers.line.biz/en/docs/messaging-api/flex-message-layout/#component-offset) in the API documentation.
                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                        offsetEnd?: string;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          type Postback

                                                                                                                                                                                                                                                                                          type Postback = {
                                                                                                                                                                                                                                                                                          data: string;
                                                                                                                                                                                                                                                                                          params?: DateTimePostback | RichMenuSwitchPostback;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            type PostbackAction

                                                                                                                                                                                                                                                                                            type PostbackAction = {
                                                                                                                                                                                                                                                                                            type: 'postback';
                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                            * String returned via webhook in the `postback.data` property of the
                                                                                                                                                                                                                                                                                            * postback event (Max: 300 characters)
                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                            data: string;
                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                            * Text displayed in the chat as a message sent by the user when the action
                                                                                                                                                                                                                                                                                            * is performed. Returned from the server through a webhook.
                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                            * - This property cannot be used with quick reply buttons. (Max: 300 characters)
                                                                                                                                                                                                                                                                                            * - The `displayText` and `text` properties cannot both be used at the same time.
                                                                                                                                                                                                                                                                                            * @deprecated
                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                            text?: string;
                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                            * Text displayed in the chat as a message sent by the user when the action is performed.
                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                            * - Required for quick reply buttons.
                                                                                                                                                                                                                                                                                            * - Optional for the other message types.
                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                            * Max: 300 characters
                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                            * The `displayText` and `text` properties cannot both be used at the same time.
                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                            displayText?: string;
                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                            • When a control associated with this action is tapped, a postback event is returned via webhook with the specified string in the data property.

                                                                                                                                                                                                                                                                                            type PostbackEvent

                                                                                                                                                                                                                                                                                            type PostbackEvent = {
                                                                                                                                                                                                                                                                                            type: 'postback';
                                                                                                                                                                                                                                                                                            postback: Postback;
                                                                                                                                                                                                                                                                                            } & ReplyableEvent;
                                                                                                                                                                                                                                                                                            • Event object for when a user performs an action on a [template message](https://developers.line.biz/en/reference/messaging-api/#template-messages).

                                                                                                                                                                                                                                                                                            type Profile

                                                                                                                                                                                                                                                                                            type Profile = {
                                                                                                                                                                                                                                                                                            displayName: string;
                                                                                                                                                                                                                                                                                            userId: string;
                                                                                                                                                                                                                                                                                            pictureUrl: string;
                                                                                                                                                                                                                                                                                            statusMessage: string;
                                                                                                                                                                                                                                                                                            language?: string;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              type QuickReply

                                                                                                                                                                                                                                                                                              type QuickReply = {
                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                              * This is a container that contains
                                                                                                                                                                                                                                                                                              * [quick reply buttons](https://developers.line.biz/en/reference/messaging-api/#quick-reply-button-object).
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * Array of objects (Max: 13)
                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                              items: QuickReplyItem[];
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • These properties are used for the quick reply.

                                                                                                                                                                                                                                                                                                For more information, see [Using quick replies](https://developers.line.biz/en/docs/messaging-api/using-quick-reply/).

                                                                                                                                                                                                                                                                                              type QuickReplyItem

                                                                                                                                                                                                                                                                                              type QuickReplyItem = {
                                                                                                                                                                                                                                                                                              type: 'action';
                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                              * URL of the icon that is displayed at the beginning of the button (Max: 1000 characters)
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * - URL scheme: https
                                                                                                                                                                                                                                                                                              * - Image format: PNG
                                                                                                                                                                                                                                                                                              * - Aspect ratio: 1:1
                                                                                                                                                                                                                                                                                              * - Data size: Up to 1 MB
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * There is no limit on the image size. If the `action` property has the
                                                                                                                                                                                                                                                                                              * following actions with empty `imageUrl`:
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * - [camera action](https://developers.line.biz/en/reference/messaging-api/#camera-action)
                                                                                                                                                                                                                                                                                              * - [camera roll action](https://developers.line.biz/en/reference/messaging-api/#camera-roll-action)
                                                                                                                                                                                                                                                                                              * - [location action](https://developers.line.biz/en/reference/messaging-api/#location-action)
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * the default icon is displayed.
                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                              imageUrl?: string;
                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                              * Action performed when this button is tapped.
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * Specify an [action object](https://developers.line.biz/en/reference/messaging-api/#action-objects).
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * The following is a list of the available actions:
                                                                                                                                                                                                                                                                                              *
                                                                                                                                                                                                                                                                                              * - [Postback action](https://developers.line.biz/en/reference/messaging-api/#postback-action)
                                                                                                                                                                                                                                                                                              * - [Message action](https://developers.line.biz/en/reference/messaging-api/#message-action)
                                                                                                                                                                                                                                                                                              * - [Datetime picker action](https://developers.line.biz/en/reference/messaging-api/#datetime-picker-action)
                                                                                                                                                                                                                                                                                              * - [Camera action](https://developers.line.biz/en/reference/messaging-api/#camera-action)
                                                                                                                                                                                                                                                                                              * - [Camera roll action](https://developers.line.biz/en/reference/messaging-api/#camera-roll-action)
                                                                                                                                                                                                                                                                                              * - [Location action](https://developers.line.biz/en/reference/messaging-api/#location-action)
                                                                                                                                                                                                                                                                                              * - [URI action](https://developers.line.biz/en/reference/messaging-api/#uri-action)
                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                              action: Action;
                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                              • This is a quick reply option that is displayed as a button.

                                                                                                                                                                                                                                                                                                For more information, see [quick reply buttons](https://developers.line.biz/en/reference/messaging-api/#quick-reply-button-object).

                                                                                                                                                                                                                                                                                              type ReceieptObject

                                                                                                                                                                                                                                                                                              type ReceieptObject =
                                                                                                                                                                                                                                                                                              | AudienceObject
                                                                                                                                                                                                                                                                                              | RedeliveryObject
                                                                                                                                                                                                                                                                                              | FilterOperatorObject<AudienceObject>
                                                                                                                                                                                                                                                                                              | FilterOperatorObject<RedeliveryObject>;

                                                                                                                                                                                                                                                                                                type ReplyableEvent

                                                                                                                                                                                                                                                                                                type ReplyableEvent = EventBase & {
                                                                                                                                                                                                                                                                                                replyToken: string;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  type RichMenu

                                                                                                                                                                                                                                                                                                  type RichMenu = {
                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                  * [`size` object](https://developers.line.biz/en/reference/messaging-api/#size-object)
                                                                                                                                                                                                                                                                                                  * which contains the width and height of the rich menu displayed in the chat.
                                                                                                                                                                                                                                                                                                  * Rich menu images must be one of the following sizes: 2500x1686px or 2500x843px.
                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                  size: Size;
                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                  * `true` to display the rich menu by default. Otherwise, `false`.
                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                  selected: boolean;
                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                  * Name of the rich menu.
                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                  * This value can be used to help manage your rich menus and is not displayed
                                                                                                                                                                                                                                                                                                  * to users.
                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                  * (Max: 300 characters)
                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                  * Text displayed in the chat bar (Max: 14 characters)
                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                  chatBarText: string;
                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                  * Array of [area objects](https://developers.line.biz/en/reference/messaging-api/#area-object)
                                                                                                                                                                                                                                                                                                  * which define the coordinates and size of tappable areas
                                                                                                                                                                                                                                                                                                  * (Max: 20 area objects)
                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                  areas: Array<{
                                                                                                                                                                                                                                                                                                  bounds: Area;
                                                                                                                                                                                                                                                                                                  action: Action<{
                                                                                                                                                                                                                                                                                                  label?: string;
                                                                                                                                                                                                                                                                                                  }>;
                                                                                                                                                                                                                                                                                                  }>;
                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                  • Rich menus consist of either of these objects.

                                                                                                                                                                                                                                                                                                    - [Rich menu object](https://developers.line.biz/en/reference/messaging-api/#rich-menu-object) without the rich menu ID. Use this object when you [create a rich menu](https://developers.line.biz/en/reference/messaging-api/#create-rich-menu). - [Rich menu response object](https://developers.line.biz/en/reference/messaging-api/#rich-menu-response-object) with the rich menu ID. This object is returned when you [get a rich menu](https://developers.line.biz/en/reference/messaging-api/#get-rich-menu) or [get a list of rich menus](https://developers.line.biz/en/reference/messaging-api/#get-rich-menu-list).

                                                                                                                                                                                                                                                                                                    [Area objects](https://developers.line.biz/en/reference/messaging-api/#area-object) and [action objects](https://developers.line.biz/en/reference/messaging-api/#action-objects) are included in these objects.

                                                                                                                                                                                                                                                                                                  type RichMenuResponse

                                                                                                                                                                                                                                                                                                  type RichMenuResponse = {
                                                                                                                                                                                                                                                                                                  richMenuId: string;
                                                                                                                                                                                                                                                                                                  } & RichMenu;

                                                                                                                                                                                                                                                                                                    type RichMenuSwitchAction

                                                                                                                                                                                                                                                                                                    type RichMenuSwitchAction = {
                                                                                                                                                                                                                                                                                                    type: 'richmenuswitch';
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                    * Action label. Optional for rich menus. Read when the user's device accessibility feature is enabled.
                                                                                                                                                                                                                                                                                                    * Max character limit: 20. Supported on LINE for iOS 8.2.0 or later.
                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                    label?: string;
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                    * Rich menu alias ID to switch to.
                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                    richMenuAliasId: string;
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                    * String returned by the postback.data property of the postback event via a webhook
                                                                                                                                                                                                                                                                                                    * Max character limit: 300
                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                    data: string;
                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                    • When a control associated with this action is tapped, the URI specified in the uri property is opened.

                                                                                                                                                                                                                                                                                                    type Room

                                                                                                                                                                                                                                                                                                    type Room = {
                                                                                                                                                                                                                                                                                                    type: 'room';
                                                                                                                                                                                                                                                                                                    roomId: string;
                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                    * ID of the source user.
                                                                                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                                                                                    * Only included in [message events](https://developers.line.biz/en/reference/messaging-api/#message-event).
                                                                                                                                                                                                                                                                                                    * Not included if the user has not agreed to the
                                                                                                                                                                                                                                                                                                    * [Official Accounts Terms of Use](https://developers.line.biz/en/docs/messaging-api/user-consent/).
                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                    userId?: string;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      type Sender

                                                                                                                                                                                                                                                                                                      type Sender = {
                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                      * Display name
                                                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                                                      * - Max character limit: 20
                                                                                                                                                                                                                                                                                                      * - Certain words such as `LINE` may not be used.
                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                      * Icon image URL
                                                                                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                                                                                      * - Max character limit: 1000
                                                                                                                                                                                                                                                                                                      * - URL scheme: https
                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                      iconUrl?: string;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        type Size

                                                                                                                                                                                                                                                                                                        type Size = {
                                                                                                                                                                                                                                                                                                        width: number;
                                                                                                                                                                                                                                                                                                        height: number;
                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                          type StickerEventMessage

                                                                                                                                                                                                                                                                                                          type StickerEventMessage = {
                                                                                                                                                                                                                                                                                                          type: 'sticker';
                                                                                                                                                                                                                                                                                                          packageId: string;
                                                                                                                                                                                                                                                                                                          stickerId: string;
                                                                                                                                                                                                                                                                                                          stickerResourceType:
                                                                                                                                                                                                                                                                                                          | 'STATIC'
                                                                                                                                                                                                                                                                                                          | 'ANIMATION'
                                                                                                                                                                                                                                                                                                          | 'SOUND'
                                                                                                                                                                                                                                                                                                          | 'ANIMATION_SOUND'
                                                                                                                                                                                                                                                                                                          | 'POPUP'
                                                                                                                                                                                                                                                                                                          | 'POPUP_SOUND'
                                                                                                                                                                                                                                                                                                          | 'NAME_TEXT'
                                                                                                                                                                                                                                                                                                          | 'PER_STICKER_TEXT';
                                                                                                                                                                                                                                                                                                          keywords: string[];
                                                                                                                                                                                                                                                                                                          } & EventMessageBase;
                                                                                                                                                                                                                                                                                                          • Message object which contains the sticker data sent from the source. For a list of basic LINE stickers and sticker IDs, see [sticker list](https://developers.line.biz/media/messaging-api/sticker_list.pdf).

                                                                                                                                                                                                                                                                                                          type StickerMessage

                                                                                                                                                                                                                                                                                                          type StickerMessage = MessageCommon & {
                                                                                                                                                                                                                                                                                                          type: 'sticker';
                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                          * Package ID for a set of stickers.
                                                                                                                                                                                                                                                                                                          * For information on package IDs, see the
                                                                                                                                                                                                                                                                                                          * [Sticker list](https://developers.line.biz/media/messaging-api/sticker_list.pdf).
                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                          packageId: string;
                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                          * Sticker ID.
                                                                                                                                                                                                                                                                                                          * For a list of sticker IDs for stickers that can be sent with the Messaging
                                                                                                                                                                                                                                                                                                          * API, see the
                                                                                                                                                                                                                                                                                                          * [Sticker list](https://developers.line.biz/media/messaging-api/sticker_list.pdf).
                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                          stickerId: string;
                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                          • See Also

                                                                                                                                                                                                                                                                                                            • [Sticker message](https://developers.line.biz/en/reference/messaging-api/#sticker-message)

                                                                                                                                                                                                                                                                                                          type TargetLimitForAdditionalMessages

                                                                                                                                                                                                                                                                                                          type TargetLimitForAdditionalMessages = {
                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                          * One of the following values to indicate whether a target limit is set or not.
                                                                                                                                                                                                                                                                                                          * - `none`: This indicates that a target limit is not set.
                                                                                                                                                                                                                                                                                                          * - `limited`: This indicates that a target limit is set.
                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                          type: 'none' | 'limited';
                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                          * The target limit for additional messages in the current month.
                                                                                                                                                                                                                                                                                                          * This property is returned when the `type` property has a value of `limited`.
                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                          value?: number;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            type TemplateButtons

                                                                                                                                                                                                                                                                                                            type TemplateButtons = {
                                                                                                                                                                                                                                                                                                            type: 'buttons';
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Image URL (Max: 2000 characters)
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - HTTPS
                                                                                                                                                                                                                                                                                                            * - JPEG or PNG
                                                                                                                                                                                                                                                                                                            * - Max width: 1024px
                                                                                                                                                                                                                                                                                                            * - Max: 1 MB
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            thumbnailImageUrl?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Aspect ratio of the image. Specify one of the following values:
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - `rectangle`: 1.51:1
                                                                                                                                                                                                                                                                                                            * - `square`: 1:1
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * The default value is `rectangle`
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageAspectRatio?: 'rectangle' | 'square';
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Size of the image. Specify one of the following values:
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - `cover`: The image fills the entire image area. Parts of the image that
                                                                                                                                                                                                                                                                                                            * do not fit in the area are not displayed.
                                                                                                                                                                                                                                                                                                            * - `contain`: The entire image is displayed in the image area. A background
                                                                                                                                                                                                                                                                                                            * is displayed in the unused areas to the left and right of vertical images
                                                                                                                                                                                                                                                                                                            * and in the areas above and below horizontal images.
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * The default value is `cover`.
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageSize?: 'cover' | 'contain';
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Background color of image. Specify a RGB color value.
                                                                                                                                                                                                                                                                                                            * The default value is `#FFFFFF` (white).
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageBackgroundColor?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Title (Max: 40 characters)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            title?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Message text
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - Max: 160 characters (no image or title)
                                                                                                                                                                                                                                                                                                            * - Max: 60 characters (message with an image or title)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            text: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Action when tapped (Max: 4)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            actions: Action[];
                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                            • Template with an image, title, text, and multiple action buttons.

                                                                                                                                                                                                                                                                                                              Because of the height limitation for buttons template messages, the lower part of the text display area will get cut off if the height limitation is exceeded. For this reason, depending on the character width, the message text may not be fully displayed even when it is within the character limits.

                                                                                                                                                                                                                                                                                                            type TemplateCarousel

                                                                                                                                                                                                                                                                                                            type TemplateCarousel = {
                                                                                                                                                                                                                                                                                                            type: 'carousel';
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Array of columns (Max: 10)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            columns: TemplateColumn[];
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Aspect ratio of the image. Specify one of the following values:
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - `rectangle`: 1.51:1
                                                                                                                                                                                                                                                                                                            * - `square`: 1:1
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * Applies to all columns. The default value is `rectangle`.
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageAspectRatio?: 'rectangle' | 'square';
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Size of the image. Specify one of the following values:
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - `cover`: The image fills the entire image area. Parts of the image that
                                                                                                                                                                                                                                                                                                            * do not fit in the area are not displayed.
                                                                                                                                                                                                                                                                                                            * - `contain`: The entire image is displayed in the image area. A background
                                                                                                                                                                                                                                                                                                            * is displayed in the unused areas to the left and right of vertical images
                                                                                                                                                                                                                                                                                                            * and in the areas above and below horizontal images.
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * Applies to all columns. The default value is `cover`.
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageSize?: 'cover' | 'contain';
                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                            • Template with multiple columns which can be cycled like a carousel. The columns will be shown in order by scrolling horizontally.

                                                                                                                                                                                                                                                                                                              Because of the height limitation for carousel template messages, the lower part of the text display area will get cut off if the height limitation is exceeded. For this reason, depending on the character width, the message text may not be fully displayed even when it is within the character limits.

                                                                                                                                                                                                                                                                                                              Keep the number of actions consistent for all columns. If you use an image or title for a column, make sure to do the same for all other columns.

                                                                                                                                                                                                                                                                                                            type TemplateColumn

                                                                                                                                                                                                                                                                                                            type TemplateColumn = {
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Image URL (Max: 2000 characters)
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - HTTPS
                                                                                                                                                                                                                                                                                                            * - JPEG or PNG
                                                                                                                                                                                                                                                                                                            * - Aspect ratio: 1:1.51
                                                                                                                                                                                                                                                                                                            * - Max width: 1024px
                                                                                                                                                                                                                                                                                                            * - Max: 1 MB
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            thumbnailImageUrl?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Background color of image. Specify a RGB color value.
                                                                                                                                                                                                                                                                                                            * The default value is `#FFFFFF` (white).
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            imageBackgroundColor?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Title (Max: 40 characters)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            title?: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Message text
                                                                                                                                                                                                                                                                                                            *
                                                                                                                                                                                                                                                                                                            * - Max: 120 characters (no image or title)
                                                                                                                                                                                                                                                                                                            * - Max: 60 characters (message with an image or title)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            text: string;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Action when image is tapped; set for the entire image, title, and text area
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            defaultAction?: Action;
                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                            * Action when tapped (Max: 3)
                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                            actions: Action[];
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              type TemplateConfirm

                                                                                                                                                                                                                                                                                                              type TemplateConfirm = {
                                                                                                                                                                                                                                                                                                              type: 'confirm';
                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                              * Message text (Max: 240 characters)
                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                              text: string;
                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                              * Action when tapped. Set 2 actions for the 2 buttons
                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                              actions: Action[];
                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                              • Template with two action buttons.

                                                                                                                                                                                                                                                                                                                Because of the height limitation for confirm template messages, the lower part of the text display area will get cut off if the height limitation is exceeded. For this reason, depending on the character width, the message text may not be fully displayed even when it is within the character limits.

                                                                                                                                                                                                                                                                                                              type TemplateContent

                                                                                                                                                                                                                                                                                                              type TemplateContent =
                                                                                                                                                                                                                                                                                                              | TemplateButtons
                                                                                                                                                                                                                                                                                                              | TemplateConfirm
                                                                                                                                                                                                                                                                                                              | TemplateCarousel
                                                                                                                                                                                                                                                                                                              | TemplateImageCarousel;

                                                                                                                                                                                                                                                                                                                type TemplateImageCarousel

                                                                                                                                                                                                                                                                                                                type TemplateImageCarousel = {
                                                                                                                                                                                                                                                                                                                type: 'image_carousel';
                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                * Array of columns (Max: 10)
                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                columns: TemplateImageColumn[];
                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                • Template with multiple images which can be cycled like a carousel. The images will be shown in order by scrolling horizontally.

                                                                                                                                                                                                                                                                                                                type TemplateImageColumn

                                                                                                                                                                                                                                                                                                                type TemplateImageColumn = {
                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                * Image URL (Max: 2000 characters)
                                                                                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                                                                                * - HTTPS
                                                                                                                                                                                                                                                                                                                * - JPEG or PNG
                                                                                                                                                                                                                                                                                                                * - Aspect ratio: 1:1
                                                                                                                                                                                                                                                                                                                * - Max width: 1024px
                                                                                                                                                                                                                                                                                                                * - Max: 1 MB
                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                imageUrl: string;
                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                * Action when image is tapped
                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                action: Action<{
                                                                                                                                                                                                                                                                                                                label?: string;
                                                                                                                                                                                                                                                                                                                }>;
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  type TemplateMessage

                                                                                                                                                                                                                                                                                                                  type TemplateMessage = MessageCommon & {
                                                                                                                                                                                                                                                                                                                  type: 'template';
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Alternative text (Max: 400 characters)
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  altText: string;
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Carousel template content
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  template: TemplateContent;
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  • Template messages are messages with predefined layouts which you can customize. For more information, see [template messages](https://developers.line.biz/en/docs/messaging-api/message-types/#template-messages).

                                                                                                                                                                                                                                                                                                                    The following template types are available:

                                                                                                                                                                                                                                                                                                                    - [Buttons](https://developers.line.biz/en/reference/messaging-api/#buttons) - [Confirm](https://developers.line.biz/en/reference/messaging-api/#confirm) - [Carousel](https://developers.line.biz/en/reference/messaging-api/#carousel) - [Image carousel](https://developers.line.biz/en/reference/messaging-api/#image-carousel)

                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                    • [Template messages](https://developers.line.biz/en/reference/messaging-api/#template-messages)

                                                                                                                                                                                                                                                                                                                  type TestWebhookEndpointResponse

                                                                                                                                                                                                                                                                                                                  type TestWebhookEndpointResponse = {
                                                                                                                                                                                                                                                                                                                  success: boolean;
                                                                                                                                                                                                                                                                                                                  timestamp: string;
                                                                                                                                                                                                                                                                                                                  statusCode: number;
                                                                                                                                                                                                                                                                                                                  reason: string;
                                                                                                                                                                                                                                                                                                                  detail: string;
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  • Response body of test webhook endpoint.

                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                    • [Test webhook endpoint](https://developers.line.biz/en/reference/messaging-api/#test-webhook-endpoint)

                                                                                                                                                                                                                                                                                                                  type TextEventMessage

                                                                                                                                                                                                                                                                                                                  type TextEventMessage = {
                                                                                                                                                                                                                                                                                                                  type: 'text';
                                                                                                                                                                                                                                                                                                                  text: string;
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Sendable LINE emojis
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  emojis?: {
                                                                                                                                                                                                                                                                                                                  index: number;
                                                                                                                                                                                                                                                                                                                  length: number;
                                                                                                                                                                                                                                                                                                                  productId: string;
                                                                                                                                                                                                                                                                                                                  emojiId: string;
                                                                                                                                                                                                                                                                                                                  }[];
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Object containing the contents of the mentioned user.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  mention?: {
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Mentioned user information.
                                                                                                                                                                                                                                                                                                                  * Max: 20 mentions
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  mentionees: {
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Index position of the user mention for a character in `text`,
                                                                                                                                                                                                                                                                                                                  * with the first character being at position 0.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  index: number;
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * The length of the text of the mentioned user. For a mention `@example`,
                                                                                                                                                                                                                                                                                                                  * 8 is the length.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  length: number;
                                                                                                                                                                                                                                                                                                                  userId: string;
                                                                                                                                                                                                                                                                                                                  }[];
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  } & EventMessageBase;
                                                                                                                                                                                                                                                                                                                  • Message object which contains the text sent from the source.

                                                                                                                                                                                                                                                                                                                  type TextMessage

                                                                                                                                                                                                                                                                                                                  type TextMessage = MessageCommon & {
                                                                                                                                                                                                                                                                                                                  type: 'text';
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Message text. You can include the following emoji:
                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                  * - LINE emojis. Use a $ character as a placeholder and specify the product ID and emoji ID of the LINE emoji you want to use in the emojis property.
                                                                                                                                                                                                                                                                                                                  * - Unicode emoji
                                                                                                                                                                                                                                                                                                                  * - (Deprecated) LINE original unicode emojis
                                                                                                                                                                                                                                                                                                                  * ([Unicode codepoint table for LINE original emoji](https://developers.line.biz/media/messaging-api/emoji-list.pdf))
                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                  * Max: 5000 characters
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  text: string;
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * One or more LINE emoji.
                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                  * Max: 20 LINE emoji
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  emojis?: {
                                                                                                                                                                                                                                                                                                                  index: number;
                                                                                                                                                                                                                                                                                                                  productId: string;
                                                                                                                                                                                                                                                                                                                  emojiId: string;
                                                                                                                                                                                                                                                                                                                  }[];
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                                                                    • [Text message](https://developers.line.biz/en/reference/messaging-api/#text-message)

                                                                                                                                                                                                                                                                                                                  type UnfollowEvent

                                                                                                                                                                                                                                                                                                                  type UnfollowEvent = {
                                                                                                                                                                                                                                                                                                                  type: 'unfollow';
                                                                                                                                                                                                                                                                                                                  } & EventBase;
                                                                                                                                                                                                                                                                                                                  • Event object for when your account is blocked.

                                                                                                                                                                                                                                                                                                                  type UnsendEvent

                                                                                                                                                                                                                                                                                                                  type UnsendEvent = {
                                                                                                                                                                                                                                                                                                                  type: 'unsend';
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * The message ID of the unsent message
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  unsend: {
                                                                                                                                                                                                                                                                                                                  messageId: string;
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  } & EventBase;
                                                                                                                                                                                                                                                                                                                  • Event object for when the user unsends a message in a [group](https://developers.line.biz/en/docs/messaging-api/group-chats/#group) or [room](https://developers.line.biz/en/docs/messaging-api/group-chats/#room). [Unsend event](https://developers.line.biz/en/reference/messaging-api/#unsend-event)

                                                                                                                                                                                                                                                                                                                  type URIAction

                                                                                                                                                                                                                                                                                                                  type URIAction = {
                                                                                                                                                                                                                                                                                                                  type: 'uri';
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * URI opened when the action is performed (Max: 1000 characters).
                                                                                                                                                                                                                                                                                                                  * Must start with `http`, `https`, or `tel`.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  uri: string;
                                                                                                                                                                                                                                                                                                                  altUri?: AltURI;
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  • When a control associated with this action is tapped, the URI specified in the uri property is opened.

                                                                                                                                                                                                                                                                                                                  type User

                                                                                                                                                                                                                                                                                                                  type User = {
                                                                                                                                                                                                                                                                                                                  type: 'user';
                                                                                                                                                                                                                                                                                                                  userId: string;
                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                    type UserInteractionStatistics

                                                                                                                                                                                                                                                                                                                    type UserInteractionStatistics = {
                                                                                                                                                                                                                                                                                                                    overview: {
                                                                                                                                                                                                                                                                                                                    requestId: string;
                                                                                                                                                                                                                                                                                                                    timestamp: number;
                                                                                                                                                                                                                                                                                                                    delivered: number;
                                                                                                                                                                                                                                                                                                                    uniqueImpression: number;
                                                                                                                                                                                                                                                                                                                    uniqueClick: number;
                                                                                                                                                                                                                                                                                                                    uniqueMediaPlayed: number;
                                                                                                                                                                                                                                                                                                                    uniqueMediaPlayed100Percent: number;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    messages: UserInteractionStatisticsOfEachMessage[];
                                                                                                                                                                                                                                                                                                                    clicks: UserInteractionStatisticsOfEachURL[];
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    • https://developers.line.biz/en/reference/messaging-api/#get-message-event

                                                                                                                                                                                                                                                                                                                    type VideoEventMessage

                                                                                                                                                                                                                                                                                                                    type VideoEventMessage = {
                                                                                                                                                                                                                                                                                                                    type: 'video';
                                                                                                                                                                                                                                                                                                                    contentProvider: ContentProvider;
                                                                                                                                                                                                                                                                                                                    } & EventMessageBase;
                                                                                                                                                                                                                                                                                                                    • Message object which contains the video content sent from the source. The binary video data can be retrieved using Client#getMessageContent.

                                                                                                                                                                                                                                                                                                                    type VideoMessage

                                                                                                                                                                                                                                                                                                                    type VideoMessage = MessageCommon & {
                                                                                                                                                                                                                                                                                                                    type: 'video';
                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                    * URL of video file (Max: 2000 characters)
                                                                                                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                                                                                                    * - **HTTPS**
                                                                                                                                                                                                                                                                                                                    * - mp4
                                                                                                                                                                                                                                                                                                                    * - Max: 1 minute
                                                                                                                                                                                                                                                                                                                    * - Max: 10 MB
                                                                                                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                                                                                                    * A very wide or tall video may be cropped when played in some environments.
                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                    originalContentUrl: string;
                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                    * URL of preview image (Max: 2000 characters)
                                                                                                                                                                                                                                                                                                                    *
                                                                                                                                                                                                                                                                                                                    * - **HTTPS**
                                                                                                                                                                                                                                                                                                                    * - JPEG
                                                                                                                                                                                                                                                                                                                    * - Max: 240 x 240
                                                                                                                                                                                                                                                                                                                    * - Max: 1 MB
                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                    previewImageUrl: string;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    • See Also

                                                                                                                                                                                                                                                                                                                      • [Video message](https://developers.line.biz/en/reference/messaging-api/#video-message)

                                                                                                                                                                                                                                                                                                                    type VideoPlayCompleteEvent

                                                                                                                                                                                                                                                                                                                    type VideoPlayCompleteEvent = {
                                                                                                                                                                                                                                                                                                                    type: 'videoPlayComplete';
                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                    * ID used to identify a video. Returns the same value as the trackingId assigned to the [video message](https://developers.line.biz/en/reference/messaging-api/#video-message).
                                                                                                                                                                                                                                                                                                                    * String
                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                    videoPlayComplete: {
                                                                                                                                                                                                                                                                                                                    trackingId: string;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    } & ReplyableEvent;
                                                                                                                                                                                                                                                                                                                    • Event for when a user finishes viewing a video at least once with the specified trackingId sent by the LINE Official Account.

                                                                                                                                                                                                                                                                                                                    type WebhookEndpointInfoResponse

                                                                                                                                                                                                                                                                                                                    type WebhookEndpointInfoResponse = {
                                                                                                                                                                                                                                                                                                                    endpoint: string;
                                                                                                                                                                                                                                                                                                                    active: boolean;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    • Response body of get webhook endpoint info.

                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                      • [Get get webhook endpoint info](https://developers.line.biz/en/reference/messaging-api/#get-webhook-endpoint-information)

                                                                                                                                                                                                                                                                                                                    type WebhookEvent

                                                                                                                                                                                                                                                                                                                    type WebhookEvent =
                                                                                                                                                                                                                                                                                                                    | MessageEvent
                                                                                                                                                                                                                                                                                                                    | UnsendEvent
                                                                                                                                                                                                                                                                                                                    | FollowEvent
                                                                                                                                                                                                                                                                                                                    | UnfollowEvent
                                                                                                                                                                                                                                                                                                                    | JoinEvent
                                                                                                                                                                                                                                                                                                                    | LeaveEvent
                                                                                                                                                                                                                                                                                                                    | MemberJoinEvent
                                                                                                                                                                                                                                                                                                                    | MemberLeaveEvent
                                                                                                                                                                                                                                                                                                                    | PostbackEvent
                                                                                                                                                                                                                                                                                                                    | VideoPlayCompleteEvent
                                                                                                                                                                                                                                                                                                                    | BeaconEvent
                                                                                                                                                                                                                                                                                                                    | AccountLinkEvent
                                                                                                                                                                                                                                                                                                                    | DeviceLinkEvent
                                                                                                                                                                                                                                                                                                                    | DeviceUnlinkEvent
                                                                                                                                                                                                                                                                                                                    | LINEThingsScenarioExecutionEvent;
                                                                                                                                                                                                                                                                                                                    • JSON objects which contain events generated on the LINE Platform.

                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                      • [Webhook event objects](https://developers.line.biz/en/reference/messaging-api/#webhook-event-objects)

                                                                                                                                                                                                                                                                                                                    type WebhookRequestBody

                                                                                                                                                                                                                                                                                                                    type WebhookRequestBody = {
                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                    * User ID of a bot that should receive webhook events. The user ID value is a string that matches the regular expression, U[0-9a-f]{32}.
                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                    destination: string;
                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                    * Information about the event
                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                    events: Array<WebhookEvent>;
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    • Request body which is sent by webhook.

                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                      • [Request body](https://developers.line.biz/en/reference/messaging-api/#request-body)

                                                                                                                                                                                                                                                                                                                    Package Files (6)

                                                                                                                                                                                                                                                                                                                    Dependencies (6)

                                                                                                                                                                                                                                                                                                                    Dev Dependencies (13)

                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@line/bot-sdk.

                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@line/bot-sdk)
                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/@line/bot-sdk"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>