@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/types/premium/business-work-hours.d.cts

@@ -0,0 +1,42 @@
+import { tl } from '@mtcute/tl';
+export interface BusinessWorkHoursInterval {
+    /** Start hour of the interval (0-23) */
+    readonly startHour: number;
+    /** Start minute of the interval (0-59) */
+    readonly startMinute: number;
+    /** End hour of the interval (0-23) */
+    readonly endHour: number;
+    /** End minute of the interval (0-59) */
+    readonly endMinute: number;
+}
+export interface BusinessWorkHoursDay {
+    /** Day of the week, 0-6, where 0 is Monday and 6 is Sunday */
+    readonly day: number;
+    /** Whether this day is open 24 hours */
+    readonly is24h: boolean;
+    /** Open intervals for this day */
+    readonly intervals: BusinessWorkHoursInterval[];
+}
+export declare function businessWorkHoursDaysToRaw(day: ReadonlyArray<BusinessWorkHoursDay>): tl.TypeBusinessWeeklyOpen[];
+/**
+ * Information about business work hours.
+ */
+export declare class BusinessWorkHours {
+    readonly raw: tl.RawBusinessWorkHours;
+    constructor(raw: tl.RawBusinessWorkHours);
+    /** Whether the business is open right now */
+    get isOpenNow(): boolean;
+    /**
+     * Identifier of the time zone in which the {@link hours} are defined,
+     * in the IANA format.
+     */
+    get timezoneId(): string;
+    /** Raw "open" intervals */
+    get intervals(): tl.TypeBusinessWeeklyOpen[];
+    /**
+     * Parsed business hours intervals per week day.
+     *
+     * @returns  Array of 7 elements, each representing a day of the week (starting from Monday = 0)
+     */
+    get days(): ReadonlyArray<BusinessWorkHoursDay>;
+}

package/highlevel/types/premium/business-work-hours.test.d.cts

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

package/highlevel/types/premium/index.d.cts

@@ -0,0 +1,12 @@
+export * from './boost-slot.js';
+export * from './boost-stats.js';
+export * from './boost.js';
+export * from './business-account.js';
+export * from './business-chat-link.js';
+export * from './business-connection.js';
+export * from './business-intro.js';
+export * from './business-location.js';
+export * from './business-work-hours.js';
+export * from './stars-gift.js';
+export * from './stars-status.js';
+export * from './stars-transaction.js';

package/highlevel/types/premium/index.d.ts

@@ -5,6 +5,7 @@ export * from './business-account.js';
 export * from './business-chat-link.js';
 export * from './business-connection.js';
 export * from './business-intro.js';
+export * from './business-location.js';
 export * from './business-work-hours.js';
 export * from './stars-gift.js';
 export * from './stars-status.js';

package/highlevel/types/premium/stars-gift.d.cts

@@ -0,0 +1,68 @@
+import { tl } from '@mtcute/tl';
+import { Sticker } from '../media/sticker.js';
+import { TextWithEntities } from '../misc/entities.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { User } from '../peers/user.js';
+/**
+ * A gift with stars attached to it.
+ */
+export declare class StarGift {
+    readonly raw: tl.TypeStarGift;
+    constructor(raw: tl.TypeStarGift);
+    /** ID of the gift */
+    get id(): tl.Long;
+    /** Whether this gift sold out and cannot be bought anymore */
+    get isSoldOut(): boolean;
+    /** Whether this gift has limited availability */
+    get isLimited(): boolean;
+    /** Additional information for sold-out gifts */
+    get soldOutInfo(): {
+        /** Date when the first gift was bought */
+        firstSale: Date;
+        /** Date when the last gift was bought */
+        lastSale: Date;
+    } | null;
+    /** Sticker associated with the gift */
+    get sticker(): Sticker;
+    /** Amount of stars the gift was purchased for */
+    get purchaseStars(): tl.Long;
+    /**
+     * Amount of stars the gift can be converted to by the recipient
+     */
+    get convertStars(): tl.Long;
+    /**
+     * For limited availability gifts,
+     * the number of remaining and total gifts available
+     */
+    get availability(): {
+        remains: number;
+        total: number;
+    } | null;
+}
+/**
+ * Information about a certain user's {@link StarGift}.
+ */
+export declare class UserStarGift {
+    readonly raw: tl.RawUserStarGift;
+    readonly peers: PeersIndex;
+    constructor(raw: tl.RawUserStarGift, peers: PeersIndex);
+    /** Whether the sender chose to appear anonymously */
+    get nameHidden(): boolean;
+    /** Whether this gift is not visible on the recipient's profile */
+    get hidden(): boolean;
+    /** Sender of the gift, if available */
+    get sender(): User | null;
+    /** Message ID where the gift was sent, if available */
+    get messageId(): number | null;
+    /** Date the gift was sent */
+    get date(): Date;
+    /** The gift itself */
+    get gift(): StarGift;
+    /** Text attached to the gift */
+    get text(): TextWithEntities | null;
+    /**
+     * If the gift was converted to stars, the amount of stars
+     * it was converted to
+     */
+    get convertStars(): tl.Long | null;
+}

package/highlevel/types/premium/stars-status.d.cts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { StarsTransaction } from './stars-transaction.js';
+export declare class StarsStatus {
+    readonly raw: tl.payments.RawStarsStatus;
+    readonly peers: PeersIndex;
+    constructor(raw: tl.payments.RawStarsStatus);
+    /** Current Telegram Stars balance */
+    get balance(): tl.RawStarsAmount;
+    /**
+     * History of Telegram Stars transactions
+     */
+    get transactions(): StarsTransaction[];
+    /** Next offset of {@link transactions} for pagination */
+    get transactionsNextOffset(): string | null;
+}

package/highlevel/types/premium/stars-status.d.ts

@@ -6,7 +6,7 @@ export declare class StarsStatus {
     readonly peers: PeersIndex;
     constructor(raw: tl.payments.RawStarsStatus);
     /** Current Telegram Stars balance */
-    get balance(): tl.Long;
+    get balance(): tl.RawStarsAmount;
     /**
      * History of Telegram Stars transactions
      */

package/highlevel/types/premium/stars-transaction.cjs

@@ -28,15 +28,19 @@ class StarsTransaction {
    * Whether this transaction is outgoing or incoming
    */
   get direction() {
-    let isNegative = this.raw.stars.isNegative();
+    let isNegative = this.raw.stars.amount.isNegative();
     if (this.raw.refund) isNegative = !isNegative;
     return isNegative ? "outgoing" : "incoming";
   }
   /** Absolute amount of stars in the transaction */
   get amount() {
     let res = this.raw.stars;
-    if (res.isNegative()) {
-      res = res.negate();
+    if (res.amount.isNegative()) {
+      res = {
+        ...res,
+        nanos: Math.abs(res.nanos),
+        amount: res.amount.negate()
+      };
     }
     return res;
   }

package/highlevel/types/premium/stars-transaction.d.cts

@@ -0,0 +1,134 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { User } from '../peers/user.js';
+import { WebDocument } from '../files/web-document.js';
+import { MessageMedia } from '../messages/message-media.js';
+import { StarGift } from './stars-gift.js';
+/**
+ * Type of the transaction.
+ *
+ *  - `unsupported`: This transaction is not supported by the current version of client
+ *  - `app_store`, `play_market`, `premium_bot`, `fragment`: This transaction is a purchase
+ *    through App Store, Play Market, Premium Bot or Fragment respectively
+ *  - `fragment_withdraw`: This transaction is a withdrawal via Fragment
+ *  - `ads`: This transaction is with the Telegram Ads platform
+ *  - `reaction`: This transaction is a paid reaction in a chat
+ *  - `gift`: This transaction is a gift from a user
+ *  - `bot_purchase`: This transaction is a purchase at a bot-operated store
+ *  - `channel_subscription`: This transaction is a subscription to a channel
+ *  - `star_gift`: This transaction is either a star gift to a user (if outgoing), or converting a star gift to stars (if incoming)
+ *  - `api_*`: This transaction is a payment for paid API features
+ *     - `api_floodskip`: This transaction is a payment for a paid bot broadcast
+ */
+export type StarsTransactionType = {
+    type: 'unsupported';
+} | {
+    type: 'app_store';
+} | {
+    type: 'play_market';
+} | {
+    type: 'premium_bot';
+} | {
+    type: 'fragment';
+} | {
+    type: 'fragment_withdraw';
+    status: 'pending' | 'success' | 'failed';
+    /** If successful, date of the withdrawal */
+    date?: Date;
+    /** If successful, URL of the withdrawal transaction */
+    url?: string;
+} | {
+    type: 'ads';
+} | {
+    type: 'reaction';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who sent the reaction
+     * - For outgoing transactions - channel which received the reaction
+     */
+    peer: Peer;
+    /** ID of the message containing the reaction */
+    messageId: number;
+} | {
+    type: 'gift';
+    /** User who sent the gift */
+    user: User;
+} | {
+    type: 'media_purchase';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who bought the media
+     * - For outgoing transactions - seller of the media
+     */
+    peer: Peer;
+    /** ID of the message containing the media */
+    messageId: number;
+    /** The bought media (available if not refunded) */
+    media?: MessageMedia[];
+} | {
+    type: 'bot_purchase';
+    /**
+     * Related user
+     *
+     * - For incoming transactions - user who bought the item
+     * - For outgoing transactions - the seller bot
+     */
+    user: User;
+    /** Photo of the item, if available */
+    photo?: WebDocument;
+    /** Title of the item */
+    title: string;
+    /** Description of the item */
+    description?: string;
+    /** Custom payload of the item */
+    payload?: Uint8Array;
+} | {
+    type: 'channel_subscription';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who subscribed to the channel
+     * - For outgoing transactions - channel which was subscribed to
+     */
+    peer: Peer;
+    /** Period of the subscription, in seconds */
+    period: number;
+} | {
+    type: 'giveaway';
+    /** Related peer */
+    peer: Peer;
+    /** ID of the message containing the giveaway where the stars were given */
+    messageId: number;
+} | {
+    type: 'star_gift';
+    /** Related peer */
+    peer: Peer;
+    /** The gift */
+    gift: StarGift;
+} | {
+    type: 'api_floodskip';
+    /** The number of billed API calls */
+    count: number;
+};
+export declare class StarsTransaction {
+    readonly raw: tl.RawStarsTransaction;
+    readonly peers: PeersIndex;
+    constructor(raw: tl.RawStarsTransaction, peers: PeersIndex);
+    /** ID of the transaction */
+    get id(): string;
+    /** Whether this transaction is a refund */
+    get isRefund(): boolean;
+    /**
+     * Whether this transaction is outgoing or incoming
+     */
+    get direction(): 'incoming' | 'outgoing';
+    /** Absolute amount of stars in the transaction */
+    get amount(): tl.RawStarsAmount;
+    /** Date of the transaction */
+    get date(): Date;
+    /** Type of this transaction */
+    get type(): StarsTransactionType;
+}

package/highlevel/types/premium/stars-transaction.d.ts

@@ -126,7 +126,7 @@ export declare class StarsTransaction {
      */
     get direction(): 'incoming' | 'outgoing';
     /** Absolute amount of stars in the transaction */
-    get amount(): tl.Long;
+    get amount(): tl.RawStarsAmount;
     /** Date of the transaction */
     get date(): Date;
     /** Type of this transaction */

package/highlevel/types/premium/stars-transaction.js

@@ -21,15 +21,19 @@ class StarsTransaction {
    * Whether this transaction is outgoing or incoming
    */
   get direction() {
-    let isNegative = this.raw.stars.isNegative();
+    let isNegative = this.raw.stars.amount.isNegative();
     if (this.raw.refund) isNegative = !isNegative;
     return isNegative ? "outgoing" : "incoming";
   }
   /** Absolute amount of stars in the transaction */
   get amount() {
     let res = this.raw.stars;
-    if (res.isNegative()) {
-      res = res.negate();
+    if (res.amount.isNegative()) {
+      res = {
+        ...res,
+        nanos: Math.abs(res.nanos),
+        amount: res.amount.negate()
+      };
     }
     return res;
   }

package/highlevel/types/reactions/emoji-status.d.cts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Information about user's emoji status
+ */
+export declare class EmojiStatus {
+    readonly raw: Exclude<tl.TypeEmojiStatus, tl.RawEmojiStatusEmpty>;
+    constructor(raw: Exclude<tl.TypeEmojiStatus, tl.RawEmojiStatusEmpty>);
+    /** ID of the custom emoji */
+    get emoji(): tl.Long;
+    /** This status is valid at most until this date */
+    get expireDate(): Date | null;
+}

package/highlevel/types/reactions/index.d.cts

@@ -0,0 +1,4 @@
+export * from './emoji-status.js';
+export * from './peer-reaction.js';
+export * from './reaction-count.js';
+export * from './types.js';

package/highlevel/types/reactions/index.d.ts

@@ -1,2 +1,4 @@
+export * from './emoji-status.js';
 export * from './peer-reaction.js';
+export * from './reaction-count.js';
 export * from './types.js';

package/highlevel/types/reactions/peer-reaction.d.cts

@@ -0,0 +1,53 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { ReactionEmoji } from './types.js';
+import { Peer } from '../peers/peer.js';
+import { User } from '../peers/user.js';
+/**
+ * Reactions of a user to a message
+ */
+export declare class PeerReaction {
+    readonly raw: tl.RawMessagePeerReaction;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMessagePeerReaction, _peers: PeersIndex);
+    /**
+     * Emoji representing the reaction
+     */
+    get emoji(): ReactionEmoji;
+    /**
+     * Whether this is a big reaction
+     */
+    get big(): boolean;
+    /**
+     * Whether this reaction is unread by the current user
+     */
+    get unread(): boolean;
+    /**
+     * ID of the user who has reacted
+     */
+    get userId(): number;
+    /**
+     * User who has reacted
+     */
+    get user(): User;
+}
+/**
+ * Information about paid reactions of a single user to a message,
+ * currently only used for a per-post leaderboard in the app.
+ */
+export declare class PaidPeerReaction {
+    readonly raw: tl.RawMessageReactor;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMessageReactor, _peers: PeersIndex);
+    /** Whether this reaction is from the current user */
+    get my(): boolean;
+    /** Whether this reaction was sent anonymously */
+    get anonymous(): boolean;
+    /**
+     * If this reaction was not sent anonymously,
+     * this field will contain the user who sent it
+     */
+    get peer(): Peer | null;
+    /** Number of reactions sent by this user */
+    get count(): number;
+}

package/highlevel/types/reactions/reaction-count.d.cts

@@ -0,0 +1,25 @@
+import { tl } from '@mtcute/tl';
+import { ReactionEmoji } from './types.js';
+/**
+ * Reaction count
+ */
+export declare class ReactionCount {
+    readonly raw: tl.RawReactionCount;
+    constructor(raw: tl.RawReactionCount);
+    /**
+     * Emoji representing the reaction
+     */
+    get emoji(): ReactionEmoji;
+    /** Whether this is a paid reaction */
+    get isPaid(): boolean;
+    /**
+     * Number of users who reacted with this emoji
+     */
+    get count(): number;
+    /**
+     * If the current user has reacted with this emoji,
+     * this field will contain the order in which the
+     * reaction was added.
+     */
+    get order(): number | null;
+}

package/highlevel/types/reactions/types.d.cts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Input version of {@link ReactionEmoji}, which also accepts bare TL object
+ */
+export type InputReaction = string | tl.Long | tl.TypeReaction;
+/**
+ * Emoji describing a reaction.
+ *
+ * Either a `string` with a unicode emoji, or a `tl.Long` for a custom emoji
+ *
+ * For paid reactions, will always contain `⭐` emoji
+ */
+export type ReactionEmoji = string | tl.Long;
+export declare function normalizeInputReaction(reaction?: InputReaction | null): tl.TypeReaction;
+export declare function toReactionEmoji(reaction: tl.TypeReaction, allowEmpty?: false): ReactionEmoji;
+export declare function toReactionEmoji(reaction: tl.TypeReaction, allowEmpty: true): ReactionEmoji | null;

package/highlevel/types/stories/all-stories.d.cts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/index.js';
+import { PeerStories } from './peer-stories.js';
+import { StoriesStealthMode } from './stealth-mode.js';
+/**
+ * All stories of the current user
+ *
+ * Returned by {@link TelegramClient.getAllStories}
+ */
+export declare class AllStories {
+    /** Raw TL object */
+    readonly raw: tl.stories.RawAllStories;
+    /** Peers index */
+    readonly _peers: PeersIndex;
+    constructor(
+    /** Raw TL object */
+    raw: tl.stories.RawAllStories);
+    /** Whether there are more stories to fetch */
+    get hasMore(): boolean;
+    /** Next offset for pagination */
+    get next(): string;
+    /** Total number of {@link PeerStories} available */
+    get total(): number;
+    /** Peers with their stories */
+    get peerStories(): PeerStories[];
+    /** Stealth mode info */
+    get stealthMode(): StoriesStealthMode | null;
+}

package/highlevel/types/stories/index.d.cts

@@ -0,0 +1,7 @@
+export * from './all-stories.js';
+export * from './interactive/index.js';
+export * from './peer-stories.js';
+export * from './stealth-mode.js';
+export * from './story-interactions.js';
+export * from './story-viewer.js';
+export * from './story.js';

package/highlevel/types/stories/interactive/base.d.cts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+export declare abstract class StoryInteractiveArea {
+    readonly raw: tl.TypeMediaArea;
+    abstract type: string;
+    constructor(raw: tl.TypeMediaArea);
+    /** X coordinate of the top-left corner of the area */
+    get x(): number;
+    /** Y coordinate of the top-left corner of the area */
+    get y(): number;
+    /** Width of the area */
+    get width(): number;
+    /** Height of the area */
+    get height(): number;
+    /** Rotation of the area */
+    get rotation(): number;
+}

package/highlevel/types/stories/interactive/channel-post.d.cts

@@ -0,0 +1,17 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../../peers/peers-index.js';
+import { Chat } from '../../peers/chat.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a channel post
+ */
+export declare class StoryInteractiveChannelPost extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaChannelPost;
+    readonly _peers: PeersIndex;
+    readonly type: "channel_post";
+    constructor(raw: tl.RawMediaAreaChannelPost, _peers: PeersIndex);
+    /** Channel being mentioned */
+    get chat(): Chat;
+    /** ID of the message being mentioned */
+    get messageId(): number;
+}

package/highlevel/types/stories/interactive/index.d.cts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../../peers/index.js';
+import { StoryInteractiveChannelPost } from './channel-post.js';
+import { StoryInteractiveLocation } from './location.js';
+import { StoryInteractiveReaction } from './reaction.js';
+import { StoryInteractiveUrl } from './url.js';
+import { StoryInteractiveVenue } from './venue.js';
+import { StoryInteractiveWeather } from './weather.js';
+export * from './input.js';
+export { StoryInteractiveChannelPost, StoryInteractiveLocation, StoryInteractiveReaction, StoryInteractiveUrl, StoryInteractiveVenue, StoryInteractiveWeather, };
+export type StoryInteractiveElement = StoryInteractiveReaction | StoryInteractiveLocation | StoryInteractiveVenue | StoryInteractiveChannelPost | StoryInteractiveUrl | StoryInteractiveWeather;
+export declare function _storyInteractiveElementFromTl(raw: tl.TypeMediaArea, peers: PeersIndex): StoryInteractiveElement;

package/highlevel/types/stories/interactive/input.d.cts

@@ -0,0 +1,68 @@
+import { tl } from '@mtcute/tl';
+import { VenueSource } from '../../media/index.js';
+import { InputReaction } from '../../reactions/index.js';
+/**
+ * Constructor for interactive story elements.
+ *
+ * @example
+ *   ```typescript
+ *      const element = StoryElement
+ *          .at({ x: 0, y: 0, width: 10, height: 10 })
+ *          .reaction('👍', { dark: true })
+ *   ```
+ */
+export declare class StoryElement {
+    private _position;
+    private constructor();
+    static at(params: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rotation?: number;
+    }): StoryElement;
+    venue(params: {
+        /**
+         * Latitude of the geolocation
+         */
+        latitude: number;
+        /**
+         * Longitude of the geolocation
+         */
+        longitude: number;
+        /**
+         * Venue name
+         */
+        title: string;
+        /**
+         * Venue address
+         */
+        address: string;
+        /**
+         * Source where this venue was acquired
+         */
+        source: VenueSource;
+    }): tl.RawMediaAreaVenue;
+    venueFromInline(queryId: tl.Long, resultId: string): tl.RawInputMediaAreaVenue;
+    location(params: {
+        /**
+         * Latitude of the geolocation
+         */
+        latitude: number;
+        /**
+         * Longitude of the geolocation
+         */
+        longitude: number;
+    }): tl.RawMediaAreaGeoPoint;
+    reaction(reaction: InputReaction, params?: {
+        /**
+         * Whether this reaction is on a dark background
+         */
+        dark?: boolean;
+        /**
+         * Whether this reaction is flipped (i.e. has tail on the left)
+         */
+        flipped?: boolean;
+    }): tl.RawMediaAreaSuggestedReaction;
+    url(url: string): tl.RawMediaAreaUrl;
+}

package/highlevel/types/stories/interactive/location.d.cts

@@ -0,0 +1,15 @@
+import { tl } from '@mtcute/tl';
+import { Location } from '../../media/location.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a location on the map
+ */
+export declare class StoryInteractiveLocation extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaGeoPoint;
+    readonly type: "location";
+    constructor(raw: tl.RawMediaAreaGeoPoint);
+    /**
+     * Geolocation
+     */
+    get location(): Location;
+}