mirror of
https://github.com/versia-pub/api.git
synced 2025-12-06 08:28:19 +01:00
2012 lines
60 KiB
TypeScript
2012 lines
60 KiB
TypeScript
import { OAuth2Client } from "@badgateway/oauth2-client";
|
|
import type { Account } from "../types/account";
|
|
import type { Activity } from "../types/activity";
|
|
import type { Announcement } from "../types/announcement";
|
|
import type { Application, ApplicationData } from "../types/application";
|
|
import type { AsyncAttachment } from "../types/async_attachment";
|
|
import type { Attachment } from "../types/attachment";
|
|
import type { Context } from "../types/context";
|
|
import type { Conversation } from "../types/conversation";
|
|
import type { Emoji } from "../types/emoji";
|
|
import type { FeaturedTag } from "../types/featured_tag";
|
|
import type { List } from "../types/list";
|
|
import type { Marker } from "../types/marker";
|
|
import type { Notification } from "../types/notification";
|
|
import type { Poll } from "../types/poll";
|
|
import type { Preferences } from "../types/preferences";
|
|
import type { PushSubscription } from "../types/push_subscription";
|
|
import type { Relationship } from "../types/relationship";
|
|
import type { Category, Report } from "../types/report";
|
|
import type { Results } from "../types/results";
|
|
import type { ScheduledStatus } from "../types/scheduled_status";
|
|
import type { Status, StatusVisibility } from "../types/status";
|
|
import type { StatusSource } from "../types/status_source";
|
|
import type { Tag } from "../types/tag";
|
|
import type { Token } from "../types/token";
|
|
import { BaseClient, type Output } from "./base";
|
|
import { DEFAULT_SCOPE, NO_REDIRECT } from "./constants";
|
|
|
|
type StatusContentType =
|
|
| "text/plain"
|
|
| "text/markdown"
|
|
| "text/html"
|
|
| "text/x.misskeymarkdown";
|
|
|
|
interface InstanceV2Output {
|
|
domain: string;
|
|
title: string;
|
|
version: string;
|
|
lysand_version: string;
|
|
source_url: string;
|
|
description: string;
|
|
usage: {
|
|
users: {
|
|
active_month: number;
|
|
};
|
|
};
|
|
thumbnail: {
|
|
url: string | null;
|
|
};
|
|
banner: {
|
|
url: string | null;
|
|
};
|
|
languages: string[];
|
|
configuration: {
|
|
urls: {
|
|
streaming: string | null;
|
|
status: string | null;
|
|
};
|
|
accounts: {
|
|
max_featured_tags: number;
|
|
};
|
|
statuses: {
|
|
max_characters: number;
|
|
max_media_attachments: number;
|
|
characters_reserved_per_url: number;
|
|
};
|
|
media_attachments: {
|
|
supported_mime_types: string[];
|
|
image_size_limit: number;
|
|
image_matrix_limit: number;
|
|
video_size_limit: number;
|
|
video_frame_rate_limit: number;
|
|
video_matrix_limit: number;
|
|
};
|
|
polls: {
|
|
max_characters_per_option: number;
|
|
max_expiration: number;
|
|
max_options: number;
|
|
min_expiration: number;
|
|
};
|
|
translation: {
|
|
enabled: boolean;
|
|
};
|
|
};
|
|
registrations: {
|
|
enabled: boolean;
|
|
approval_required: boolean;
|
|
message: string | null;
|
|
url: string | null;
|
|
};
|
|
contact: {
|
|
email: string | null;
|
|
account: Account | null;
|
|
};
|
|
rules: {
|
|
id: string;
|
|
text: string;
|
|
hint: string;
|
|
}[];
|
|
sso: {
|
|
forced: boolean;
|
|
providers: {
|
|
name: string;
|
|
icon: string;
|
|
id: string;
|
|
}[];
|
|
};
|
|
}
|
|
|
|
export class LysandClient extends BaseClient {
|
|
public acceptFollowRequest(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/follow_requests/${id}/authorize`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public addAccountToList(
|
|
id: string,
|
|
account_ids: string[],
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.post<void>(
|
|
`/api/v1/lists/${id}/accounts`,
|
|
{ account_ids },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public addReactionToAnnouncement(
|
|
id: string,
|
|
name: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.put<void>(
|
|
`/api/v1/announcements/${id}/reactions/${name}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public blockAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/block`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public blockDomain(
|
|
domain: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.post<void>("/api/v1/domain_blocks", { domain }, extra);
|
|
}
|
|
|
|
public bookmarkStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/bookmark`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public cancelScheduledStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.delete<void>(
|
|
`/api/v1/scheduled_statuses/${id}/cancel`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public createApp(
|
|
client_name: string,
|
|
options?: Partial<{
|
|
redirect_uris: string;
|
|
scopes: string[];
|
|
website?: string;
|
|
}>,
|
|
): Promise<Output<Application>> {
|
|
return this.postForm<ApplicationData>("/api/v1/apps", {
|
|
client_name,
|
|
...options,
|
|
scopes: options?.scopes?.join(" ") || DEFAULT_SCOPE.join(" "),
|
|
redirect_uris: options?.redirect_uris || NO_REDIRECT,
|
|
});
|
|
}
|
|
|
|
public createEmojiReaction(
|
|
id: string,
|
|
emoji: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/reactions/${emoji}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public createFeaturedTag(
|
|
name: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<FeaturedTag>> {
|
|
return this.post<FeaturedTag>("/api/v1/featured_tags", { name }, extra);
|
|
}
|
|
|
|
public createList(
|
|
title: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<List>> {
|
|
return this.post<List>("/api/v1/lists", { title }, extra);
|
|
}
|
|
|
|
public deleteAccountsFromList(
|
|
id: string,
|
|
account_ids: string[],
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.delete<void>(
|
|
`/api/v1/lists/${id}/accounts`,
|
|
{ account_ids },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public deleteConversation(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.delete<void>(
|
|
`/api/v1/conversations/${id}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public deleteEmojiReaction(
|
|
id: string,
|
|
emoji: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.delete<Status>(
|
|
`/api/v1/statuses/${id}/reactions/${emoji}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public deleteFeaturedTag(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.delete<void>(
|
|
`/api/v1/featured_tags/${id}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public deleteList(id: string, extra?: RequestInit): Promise<Output<void>> {
|
|
return this.delete<void>(`/api/v1/lists/${id}`, undefined, extra);
|
|
}
|
|
|
|
public deletePushSubscription(extra?: RequestInit): Promise<Output<void>> {
|
|
return this.delete<void>("/api/v1/push/subscription", undefined, extra);
|
|
}
|
|
|
|
public deleteStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.delete<Status>(`/api/v1/statuses/${id}`, undefined, extra);
|
|
}
|
|
|
|
// TODO: directStreaming
|
|
|
|
public dismissInstanceAnnouncement(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.post<void>(
|
|
`/api/v1/instance/announcements/${id}/dismiss`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public dismissNotification(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.post<void>(
|
|
`/api/v1/notifications/${id}/dismiss`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public dismissNotifications(extra?: RequestInit): Promise<Output<void>> {
|
|
return this.post<void>("/api/v1/notifications/clear", undefined, extra);
|
|
}
|
|
|
|
public editStatus(
|
|
id: string,
|
|
options: Partial<{
|
|
status: string;
|
|
content_type: StatusContentType;
|
|
media_ids: string[];
|
|
poll: Partial<{
|
|
expires_in: number;
|
|
hide_totals: boolean;
|
|
multiple: boolean;
|
|
options: string[];
|
|
}>;
|
|
sensitive: boolean;
|
|
spoiler_text: string;
|
|
language: string;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.put<Status>(
|
|
`/api/v1/statuses/${id}`,
|
|
{ ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public favouriteStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/favourite`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public fetchAccessToken(
|
|
client_id: string,
|
|
client_secret: string,
|
|
code?: string,
|
|
redirect_uri: string = NO_REDIRECT,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Token>> {
|
|
return this.postForm<Token>(
|
|
"/oauth/token",
|
|
{
|
|
client_id,
|
|
client_secret,
|
|
code,
|
|
redirect_uri,
|
|
grant_type: "authorization_code",
|
|
},
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public followAccount(
|
|
id: string,
|
|
options?: Partial<{
|
|
reblogs: boolean;
|
|
notify: boolean;
|
|
languages: string[];
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/follow`,
|
|
{ ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public followTag(id: string, extra?: RequestInit): Promise<Output<Tag>> {
|
|
return this.post<Tag>(`/api/v1/tags/${id}/follow`, undefined, extra);
|
|
}
|
|
|
|
public generateAuthUrl(
|
|
client_id: string,
|
|
client_secret: string,
|
|
options: Partial<{
|
|
redirect_uri: string;
|
|
scopes: string[];
|
|
}>,
|
|
): Promise<string> {
|
|
const oauthClient = new OAuth2Client({
|
|
server: this.baseUrl.toString(),
|
|
clientId: client_id,
|
|
clientSecret: client_secret,
|
|
tokenEndpoint: "/oauth/token",
|
|
authorizationEndpoint: "/oauth/authorize",
|
|
});
|
|
|
|
return oauthClient.authorizationCode.getAuthorizeUri({
|
|
redirectUri: options.redirect_uri || NO_REDIRECT,
|
|
scope: options.scopes || DEFAULT_SCOPE,
|
|
});
|
|
}
|
|
|
|
public getAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account>> {
|
|
return this.get<Account>(`/api/v1/accounts/${id}`, extra);
|
|
}
|
|
|
|
public getAccountFollowers(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(
|
|
`/api/v1/accounts/${id}/followers?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getAccountFollowing(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(
|
|
`/api/v1/accounts/${id}/following?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getAccountLists(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<List[]>> {
|
|
return this.get<List[]>(`/api/v1/accounts/${id}/lists`, extra);
|
|
}
|
|
|
|
public getAccountStatuses(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
only_media: boolean;
|
|
pinned: boolean;
|
|
exclude_replies: boolean;
|
|
exclude_reblogs: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.only_media) params.set("only_media", "true");
|
|
if (options.pinned) params.set("pinned", "true");
|
|
if (options.exclude_replies) params.set("exclude_replies", "true");
|
|
if (options.exclude_reblogs) params.set("exclude_reblogs", "true");
|
|
}
|
|
|
|
return this.get<Status[]>(
|
|
`/api/v1/accounts/${id}/statuses?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getAccountsInList(
|
|
id: string,
|
|
options: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(
|
|
`/api/v1/lists/${id}/accounts?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getBlocks(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/blocks?${params}`);
|
|
}
|
|
|
|
public getBookmarks(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Status[]>(`/api/v1/bookmarks?${params}`);
|
|
}
|
|
|
|
public getConversationTimeline(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Conversation[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Conversation[]>(
|
|
`/api/v1/conversations/${id}/timeline?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getDomainBlocks(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<string[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<string[]>(`/api/v1/domain_blocks?${params}`);
|
|
}
|
|
|
|
public getEndorsements(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/endorsements?${params}`, extra);
|
|
}
|
|
|
|
public getFavourites(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Status[]>(`/api/v1/favourites?${params}`);
|
|
}
|
|
|
|
public getFeaturedTags(
|
|
extra?: RequestInit,
|
|
): Promise<Output<FeaturedTag[]>> {
|
|
return this.get<FeaturedTag[]>("/api/v1/featured_tags", extra);
|
|
}
|
|
|
|
// TODO: getFilter
|
|
// TODO: getFilters
|
|
|
|
public getFollowRequests(
|
|
options?: Partial<{
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/follow_requests?${params}`);
|
|
}
|
|
|
|
public getFollowedTags(extra?: RequestInit): Promise<Output<Tag[]>> {
|
|
return this.get<Tag[]>("/api/v1/followed_tags", extra);
|
|
}
|
|
|
|
public getHomeTimeline(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
local: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.local) params.set("local", "true");
|
|
}
|
|
|
|
return this.get<Status[]>(`/api/v1/timelines/home?${params}`, extra);
|
|
}
|
|
|
|
public getInstance(extra?: RequestInit): Promise<Output<InstanceV2Output>> {
|
|
return this.get<InstanceV2Output>("/api/v2/instance", extra);
|
|
}
|
|
|
|
public getInstanceActivity(
|
|
extra?: RequestInit,
|
|
): Promise<Output<Activity[]>> {
|
|
return this.get<Activity[]>("/api/v1/instance/activity", extra);
|
|
}
|
|
|
|
public getInstanceAnnouncements(
|
|
extra?: RequestInit,
|
|
): Promise<Output<Announcement[]>> {
|
|
return this.get<Announcement[]>(
|
|
"/api/v1/instance/announcements",
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public getInstanceCustomEmojis(
|
|
extra?: RequestInit,
|
|
): Promise<Output<Emoji[]>> {
|
|
return this.get<Emoji[]>("/api/v1/custom_emojis", extra);
|
|
}
|
|
|
|
public getInstanceDirectory(
|
|
options?: Partial<{
|
|
limit: number;
|
|
local: boolean;
|
|
offset: number;
|
|
order: "active" | "new";
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.local) params.set("local", "true");
|
|
if (options.offset) params.set("offset", options.offset.toString());
|
|
if (options.order) params.set("order", options.order);
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/directory?${params}`, extra);
|
|
}
|
|
|
|
public getInstancePeers(extra?: RequestInit): Promise<Output<string[]>> {
|
|
return this.get<string[]>("/api/v1/instance/peers", extra);
|
|
}
|
|
|
|
public getInstanceTrends(
|
|
options?: Partial<{ limit: number }>,
|
|
): Promise<Output<Tag[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Tag[]>(`/api/v1/trends?${params}`);
|
|
}
|
|
|
|
public getList(id: string, extra?: RequestInit): Promise<Output<List>> {
|
|
return this.get<List>(`/api/v1/lists/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/timelines/list/:id
|
|
*
|
|
* @param id Local ID of the list in the database.
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @return Array of statuses.
|
|
*/
|
|
public getListTimeline(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Status[]>(
|
|
`/api/v1/timelines/list/${id}?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/lists
|
|
*
|
|
* @return Array of lists.
|
|
*/
|
|
public getLists(extra?: RequestInit): Promise<Output<List[]>> {
|
|
return this.get<List[]>("/api/v1/lists", extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/timelines/public
|
|
*
|
|
* @param options.only_media Show only statuses with media attached? Defaults to false.
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @param options.only_media Show only statuses with media attached? Defaults to false.
|
|
* @return Array of statuses.
|
|
*/
|
|
public getLocalTimeline(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
only_media: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.only_media) params.set("only_media", "true");
|
|
}
|
|
|
|
return this.get<Status[]>(`/api/v1/timelines/public?${params}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/markers
|
|
*
|
|
* @param timelines Array of timeline names, String enum anyOf home, notifications.
|
|
* @return Marker or empty object.
|
|
*/
|
|
public getMarkers(
|
|
timelines: ("home" | "notifications")[],
|
|
): Promise<Output<Marker | Record<never, never>>> {
|
|
const params = new URLSearchParams();
|
|
|
|
for (const timeline of timelines) {
|
|
params.append("timelines[]", timeline);
|
|
}
|
|
|
|
return this.get<Marker | Record<never, never>>(
|
|
`/api/v1/markers?${params}`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/media/:id
|
|
*
|
|
* @param id Target media ID.
|
|
* @return Attachment
|
|
*/
|
|
public getMedia(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Attachment>> {
|
|
return this.get<Attachment>(`/api/v1/media/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/mutes
|
|
*
|
|
* @param options.limit Max number of results to return. Defaults to 40.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @return Array of accounts.
|
|
*/
|
|
public getMutes(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/mutes?${params}`);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/notifications/:id
|
|
*
|
|
* @param id Target notification ID.
|
|
* @return Notification.
|
|
*/
|
|
public getNotification(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Notification>> {
|
|
return this.get<Notification>(`/api/v1/notifications/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/notifications
|
|
*
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @param options.exclude_types Array of types to exclude.
|
|
* @param options.account_id Return only notifications received from this account.
|
|
* @return Array of notifications.
|
|
*/
|
|
public getNotifications(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
exclude_types: string[];
|
|
account_id: string;
|
|
}>,
|
|
): Promise<Output<Notification[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.exclude_types) {
|
|
for (const type of options.exclude_types) {
|
|
params.append("exclude_types[]", type);
|
|
}
|
|
}
|
|
if (options.account_id)
|
|
params.set("account_id", options.account_id);
|
|
}
|
|
|
|
return this.get<Notification[]>(`/api/v1/notifications?${params}`);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/polls/:id
|
|
*
|
|
* @param id Target poll ID.
|
|
* @return Poll.
|
|
*/
|
|
public getPoll(id: string, extra?: RequestInit): Promise<Output<Poll>> {
|
|
return this.get<Poll>(`/api/v1/polls/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/preferences
|
|
*
|
|
* @return Preferences.
|
|
*/
|
|
public getPreferences(extra?: RequestInit): Promise<Output<Preferences>> {
|
|
return this.get<Preferences>("/api/v1/preferences", extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/timelines/public
|
|
*
|
|
* @param options.only_media Show only statuses with media attached? Defaults to false.
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @return Array of statuses.
|
|
*/
|
|
public getPublicTimeline(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
only_media: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.only_media) params.set("only_media", "true");
|
|
}
|
|
|
|
return this.get<Status[]>(`/api/v1/timelines/public?${params}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/push/subscription
|
|
*
|
|
* @return PushSubscription.
|
|
*/
|
|
public getPushSubscription(
|
|
extra?: RequestInit,
|
|
): Promise<Output<PushSubscription>> {
|
|
return this.get<PushSubscription>("/api/v1/push/subscription", extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/accounts/relationships
|
|
*
|
|
* @param id The account ID.
|
|
* @param options.with_suspended Include relationships with suspended accounts? Defaults to false.
|
|
* @return Relationship
|
|
*/
|
|
public getRelationship(
|
|
id: string,
|
|
options?: Partial<{
|
|
with_suspended: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.getRelationships([id], options, extra).then((r) => ({
|
|
data: r.data[0],
|
|
headers: r.headers,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/accounts/relationships
|
|
*
|
|
* @param ids Array of account IDs.
|
|
* @param options.with_suspended Include relationships with suspended accounts? Defaults to false.
|
|
* @return Array of Relationship.
|
|
*/
|
|
public getRelationships(
|
|
ids: string[],
|
|
options?: Partial<{
|
|
with_suspended: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
for (const id of ids) {
|
|
params.append("id[]", id);
|
|
}
|
|
|
|
if (options) {
|
|
if (options.with_suspended) params.set("with_suspended", "true");
|
|
}
|
|
|
|
return this.get<Relationship[]>(
|
|
`/api/v1/accounts/relationships?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/scheduled_statuses/:id
|
|
*
|
|
* @param id Target status ID.
|
|
* @return ScheduledStatus.
|
|
*/
|
|
public getScheduledStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<ScheduledStatus>> {
|
|
return this.get<ScheduledStatus>(
|
|
`/api/v1/scheduled_statuses/${id}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/scheduled_statuses
|
|
*
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @return Array of scheduled statuses.
|
|
*/
|
|
public getScheduledStatuses(
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<ScheduledStatus[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<ScheduledStatus[]>(
|
|
`/api/v1/scheduled_statuses?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/statuses/:id
|
|
*
|
|
* @param id The target status id.
|
|
* @return Status
|
|
*/
|
|
public getStatus(id: string, extra?: RequestInit): Promise<Output<Status>> {
|
|
return this.get<Status>(`/api/v1/statuses/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/statuses/:id/context
|
|
*
|
|
* Get parent and child statuses.
|
|
* @param id The target status id.
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @return Context
|
|
*/
|
|
public getStatusContext(
|
|
id: string,
|
|
options?: Partial<{
|
|
limit: number;
|
|
max_id: string;
|
|
since_id: string;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Context>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
}
|
|
|
|
return this.get<Context>(
|
|
`/api/v1/statuses/${id}/context?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/statuses/:id/favourited_by
|
|
*
|
|
* @param id The target status id.
|
|
* @param options.limit Max number of results to return. Defaults to 40.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @return Array of accounts.
|
|
*/
|
|
public getStatusFavouritedBy(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(
|
|
`/api/v1/statuses/${id}/favourited_by?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/statuses/:id/reblogged_by
|
|
*
|
|
* @param id The target status id.
|
|
* @param options.limit Max number of results to return. Defaults to 40.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @return Array of accounts.
|
|
*/
|
|
public getStatusRebloggedBy(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(
|
|
`/api/v1/statuses/${id}/reblogged_by?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/statuses/:id/source
|
|
*
|
|
* Obtain the source properties for a status so that it can be edited.
|
|
* @param id The target status id.
|
|
* @return StatusSource
|
|
*/
|
|
public getStatusSource(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<StatusSource>> {
|
|
return this.get<StatusSource>(`/api/v1/statuses/${id}/source`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/featured_tags/suggestions
|
|
*
|
|
* @return Array of tag.
|
|
*/
|
|
public getSuggestedTags(extra?: RequestInit): Promise<Output<Tag[]>> {
|
|
return this.get<Tag[]>("/api/v1/featured_tags/suggestions", extra);
|
|
}
|
|
|
|
public getSuggestions(
|
|
options?: Partial<{ limit: number }>,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/suggestions?${params}`);
|
|
}
|
|
|
|
public getTag(id: string, extra?: RequestInit): Promise<Output<Tag>> {
|
|
return this.get<Tag>(`/api/v1/tags/${id}`, extra);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v1/timelines/tag/:hashtag
|
|
*
|
|
* @param hashtag Content of a #hashtag, not including # symbol.
|
|
* @param options.local Show only local statuses? Defaults to false.
|
|
* @param options.only_media Show only statuses with media attached? Defaults to false.
|
|
* @param options.limit Max number of results to return. Defaults to 20.
|
|
* @param options.max_id Return results older than ID.
|
|
* @param options.since_id Return results newer than ID.
|
|
* @param options.min_id Return results immediately newer than ID.
|
|
* @return Array of statuses.
|
|
*/
|
|
public getTagTimeline(
|
|
id: string,
|
|
options?: Partial<{
|
|
max_id: string;
|
|
min_id: string;
|
|
since_id: string;
|
|
limit: number;
|
|
local: boolean;
|
|
only_media: boolean;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
if (options) {
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.local) params.set("local", "true");
|
|
if (options.only_media) params.set("only_media", "true");
|
|
}
|
|
|
|
return this.get<Status[]>(
|
|
`/api/v1/timelines/tag/${id}?${params}`,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
// TODO: listStreaming
|
|
// TODO: localStreaming
|
|
|
|
/**
|
|
* GET /api/v1/accounts/lookup
|
|
*
|
|
* @param acct The username or Webfinger address to lookup.
|
|
* @return Account.
|
|
*/
|
|
public lookupAccount(
|
|
acct: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account>> {
|
|
const params = new URLSearchParams();
|
|
|
|
params.set("q", acct);
|
|
|
|
return this.get<Account>(`/api/v1/accounts/search?${params}`, extra);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/accounts/:id/mute
|
|
*
|
|
* @param id The account ID.
|
|
* @param options.notifications Mute notifications in addition to statuses.
|
|
* @param options.duration Duration of mute in seconds. Defaults to indefinite.
|
|
* @return Relationship
|
|
*/
|
|
public muteAccount(
|
|
id: string,
|
|
options?: Partial<{ notifications: boolean; duration: number }>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/mute`,
|
|
{ ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/statuses/:id/mute
|
|
*
|
|
* @param id The target status id.
|
|
* @return Status
|
|
*/
|
|
public muteStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/mute`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/accounts/:id/pin
|
|
*
|
|
* @param id The account ID.
|
|
* @return Relationship
|
|
*/
|
|
public pinAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/pin`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/statuses/:id/pin
|
|
* @param id The target status id.
|
|
* @return Status
|
|
*/
|
|
public pinStatus(id: string, extra?: RequestInit): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/pin`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/statuses
|
|
*
|
|
* @param status Text content of status.
|
|
* @param options.media_ids Array of Attachment ids.
|
|
* @param options.poll Poll object.
|
|
* @param options.in_reply_to_id ID of the status being replied to, if status is a reply.
|
|
* @param options.quote_id ID of the status being quoted to, if status is a quote.
|
|
* @param options.sensitive Mark status and attached media as sensitive?
|
|
* @param options.spoiler_text Text to be shown as a warning or subject before the actual content.
|
|
* @param options.visibility Visibility of the posted status.
|
|
* @param options.content_type Content type of the status (MIME format).
|
|
* @param options.language ISO 639 language code for this status.
|
|
* @param options.scheduled_at ISO 8601 Datetime at which to schedule a status.
|
|
* @param options.local_only Post status to local timeline only?
|
|
* @return Status. When options.scheduled_at is present, ScheduledStatus is returned instead.
|
|
*/
|
|
public postStatus(
|
|
status: string,
|
|
options: {
|
|
in_reply_to_id?: string;
|
|
quote_id?: string;
|
|
media_ids?: string[];
|
|
sensitive?: boolean;
|
|
spoiler_text?: string;
|
|
visibility?: StatusVisibility;
|
|
content_type?: StatusContentType;
|
|
scheduled_at?: string;
|
|
language?: string;
|
|
local_only?: boolean;
|
|
poll?: {
|
|
expires_in?: number;
|
|
hide_totals?: boolean;
|
|
multiple?: boolean;
|
|
options: string[];
|
|
};
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status | ScheduledStatus>> {
|
|
return this.post<Status | ScheduledStatus>(
|
|
"/api/v1/statuses",
|
|
{ status, ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
// TODO: publicStreaming
|
|
|
|
public readConversation(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Conversation>> {
|
|
return this.post<Conversation>(
|
|
`/api/v1/conversations/${id}/read`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/statuses/:id/reblog
|
|
*
|
|
* @param id The target status id.
|
|
* @param options.visibility Visibility of the reblogged status.
|
|
* @return Status.
|
|
*/
|
|
public reblogStatus(
|
|
id: string,
|
|
options?: Partial<{ visibility: StatusVisibility }>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/reblog`,
|
|
{ ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /oauth/token
|
|
*
|
|
* Revoke an OAuth token.
|
|
* @param client_id will be generated by #createApp or #registerApp
|
|
* @param client_secret will be generated by #createApp or #registerApp
|
|
* @param token will be get #fetchAccessToken
|
|
*/
|
|
public refreshToken(
|
|
client_id: string,
|
|
client_secret: string,
|
|
refresh_token: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Token>> {
|
|
return this.post<Token>(
|
|
"/oauth/token",
|
|
{
|
|
client_id,
|
|
client_secret,
|
|
grant_type: "refresh_token",
|
|
refresh_token,
|
|
},
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/accounts
|
|
*
|
|
* @param username Username for the account.
|
|
* @param email Email for the account.
|
|
* @param password Password for the account.
|
|
* @param agreement Whether the user agrees to the local rules, terms, and policies.
|
|
* @param locale The language of the confirmation email that will be sent
|
|
* @param reason Text that will be reviewed by moderators if registrations require manual approval.
|
|
* @return An account token.
|
|
*/
|
|
public registerAccount(
|
|
username: string,
|
|
email: string,
|
|
password: string,
|
|
agreement: boolean,
|
|
locale: string,
|
|
reason: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account>> {
|
|
return this.postForm<Account>(
|
|
"/api/v1/accounts",
|
|
{ username, email, password, agreement, locale, reason },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/apps
|
|
*
|
|
* Create an application.
|
|
* @param client_name your application's name
|
|
* @param options Form Data
|
|
*/
|
|
public registerApp(
|
|
client_name: string,
|
|
options: {
|
|
redirect_uris: string;
|
|
scopes?: string;
|
|
website?: string;
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<ApplicationData>> {
|
|
return this.post<ApplicationData>(
|
|
"/api/v1/apps",
|
|
{ client_name, ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public rejectFollowRequest(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/follow_requests/${id}/reject`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public removeReactionFromAnnouncement(
|
|
id: string,
|
|
name: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Announcement>> {
|
|
return this.delete<Announcement>(
|
|
`/api/v1/announcements/${id}/reactions/${name}`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/reports
|
|
*
|
|
* @param account_id Target account ID.
|
|
* @param options.status_ids Array of Statuses ids to attach to the report.
|
|
* @param options.comment The reason for the report. Default maximum of 1000 characters.
|
|
* @param options.forward If the account is remote, should the report be forwarded to the remote admin?
|
|
* @param options.category Specify if the report is due to spam, violation of enumerated instance rules, or some other reason. Defaults to other. Will be set to violation if rule_ids[] is provided (regardless of any category value you provide).
|
|
* @param options.rule_ids For violation category reports, specify the ID of the exact rules broken. Rules and their IDs are available via GET /api/v1/instance/rules and GET /api/v1/instance.
|
|
* @return Report.
|
|
*/
|
|
public report(
|
|
account_id: string,
|
|
options: {
|
|
status_ids?: string[];
|
|
rule_ids?: string[];
|
|
comment: string;
|
|
forward?: boolean;
|
|
category?: Category;
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<Report>> {
|
|
return this.post<Report>(
|
|
"/api/v1/reports",
|
|
{ account_id, ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public revokeToken(
|
|
client_id: string,
|
|
client_secret: string,
|
|
token: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.post<void>(
|
|
"/oauth/revoke",
|
|
{ client_id, client_secret, token },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* POST /api/v1/markers
|
|
*
|
|
* @param options.home Marker position of the last read status ID in home timeline.
|
|
* @param options.notifications Marker position of the last read notification ID in notifications.
|
|
* @return Marker.
|
|
*/
|
|
public saveMarkers(
|
|
options: Partial<{
|
|
home: {
|
|
last_read_id: string;
|
|
};
|
|
notifications: {
|
|
last_read_id: string;
|
|
};
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Marker>> {
|
|
return this.post<Marker>("/api/v1/markers", options, extra);
|
|
}
|
|
|
|
public scheduleStatus(
|
|
id: string,
|
|
scheduled_at?: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<ScheduledStatus>> {
|
|
return this.put<ScheduledStatus>(
|
|
`/api/v1/scheduled_statuses/${id}`,
|
|
{ scheduled_at },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* GET /api/v2/search
|
|
*
|
|
* @param q The search query.
|
|
* @param type Enum of search target.
|
|
* @param options.limit Maximum number of results to load, per type. Defaults to 20. Max 40.
|
|
* @param options.max_id Return results older than this id.
|
|
* @param options.min_id Return results immediately newer than this id.
|
|
* @param options.resolve Attempt WebFinger lookup. Defaults to false.
|
|
* @param options.following Only include accounts that the user is following. Defaults to false.
|
|
* @param options.account_id If provided, statuses returned will be authored only by this account.
|
|
* @param options.exclude_unreviewed Filter out unreviewed tags? Defaults to false.
|
|
* @return Results.
|
|
*/
|
|
public search(
|
|
q: string,
|
|
options: Partial<{
|
|
account_id: string;
|
|
exclude_unreviewed: boolean;
|
|
following: boolean;
|
|
limit: number;
|
|
max_id: string;
|
|
min_id: string;
|
|
offset: number;
|
|
resolve: boolean;
|
|
type: "accounts" | "hashtags" | "statuses";
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Results>> {
|
|
const params = new URLSearchParams();
|
|
|
|
params.set("q", q);
|
|
|
|
if (options) {
|
|
if (options.account_id)
|
|
params.set("account_id", options.account_id);
|
|
if (options.exclude_unreviewed)
|
|
params.set("exclude_unreviewed", "true");
|
|
if (options.following) params.set("following", "true");
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.min_id) params.set("min_id", options.min_id);
|
|
if (options.offset) params.set("offset", options.offset.toString());
|
|
if (options.resolve) params.set("resolve", "true");
|
|
if (options.type) params.set("type", options.type);
|
|
}
|
|
|
|
return this.get<Results>(`/api/v2/search?${params}`, extra);
|
|
}
|
|
|
|
public searchAccount(
|
|
q: string,
|
|
options: Partial<{
|
|
following: boolean;
|
|
limit: number;
|
|
max_id: string;
|
|
resolve: boolean;
|
|
since_id: string;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account[]>> {
|
|
const params = new URLSearchParams();
|
|
|
|
params.set("q", q);
|
|
|
|
if (options) {
|
|
if (options.following) params.set("following", "true");
|
|
if (options.limit) params.set("limit", options.limit.toString());
|
|
if (options.max_id) params.set("max_id", options.max_id);
|
|
if (options.resolve) params.set("resolve", "true");
|
|
if (options.since_id) params.set("since_id", options.since_id);
|
|
}
|
|
|
|
return this.get<Account[]>(`/api/v1/accounts/search?${params}`, extra);
|
|
}
|
|
|
|
// TODO: streamingURL
|
|
|
|
/**
|
|
* POST /api/v1/push/subscription
|
|
*
|
|
* @param subscription.endpoint Endpoint URL that is called when a notification event occurs.
|
|
* @param subscription.keys.p256dh User agent public key. Base64 encoded string of public key of ECDH key using prime256v1 curve.
|
|
* @param subscription.keys Auth secret. Base64 encoded string of 16 bytes of random data.
|
|
* @param data.alerts.follow Receive follow notifications?
|
|
* @param data.alerts.favourite Receive favourite notifications?
|
|
* @param data.alerts.reblog Receive reblog notifictaions?
|
|
* @param data.alerts.mention Receive mention notifications?
|
|
* @param data.alerts.poll Receive poll notifications?
|
|
* @param data.alerts.status Receive status notifications?
|
|
* @param data.alerts.follow_request Receive follow request notifications?
|
|
* @param data.alerts.update Receive status update notifications?
|
|
* @param data.alerts.admin.sign_up Receive sign up notifications?
|
|
* @param data.alerts.admin.report Receive report notifications?
|
|
* @param data.policy Notification policy. Defaults to all.
|
|
* @return PushSubscription.
|
|
*/
|
|
public subscribePushNotifications(
|
|
subscription: {
|
|
endpoint: string;
|
|
keys: {
|
|
auth: string;
|
|
p256dh: string;
|
|
};
|
|
},
|
|
data?: {
|
|
alerts: Partial<{
|
|
favourite: boolean;
|
|
follow: boolean;
|
|
mention: boolean;
|
|
poll: boolean;
|
|
reblog: boolean;
|
|
status: boolean;
|
|
follow_request: boolean;
|
|
update: boolean;
|
|
"admin.sign_up": boolean;
|
|
"admin.report": boolean;
|
|
}>;
|
|
policy?: "all" | "followed" | "follower" | "none";
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<PushSubscription>> {
|
|
return this.post<PushSubscription>(
|
|
"/api/v1/push/subscription",
|
|
{ subscription, data },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
// TODO: tagStreaming
|
|
|
|
public unblockAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/unblock`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unblockDomain(
|
|
domain: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<void>> {
|
|
return this.delete<void>("/api/v1/domain_blocks", { domain }, extra);
|
|
}
|
|
|
|
public unbookmarkStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/unbookmark`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unfavouriteStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/unfavourite`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unfollowAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/unfollow`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unmuteAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/unmute`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unpinAccount(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Relationship>> {
|
|
return this.post<Relationship>(
|
|
`/api/v1/accounts/${id}/unpin`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unpinStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/unpin`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public unreblogStatus(
|
|
id: string,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Status>> {
|
|
return this.post<Status>(
|
|
`/api/v1/statuses/${id}/unreblog`,
|
|
undefined,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* PATCH /api/v1/accounts/update_credentials
|
|
*
|
|
* @param options.avatar Avatar image, as a File
|
|
* @param options.bot Is this account a bot?
|
|
* @param options.discoverable Should this account be included in directory?
|
|
* @param options.display_name Account display name.
|
|
* @param options.fields_attributes Array of profile metadata.
|
|
* @param options.header Header image, as a File
|
|
* @param options.locked Is this account locked?
|
|
* @param options.note Brief account description.
|
|
* @param options.source Source metadata.
|
|
* @return An account.
|
|
*/
|
|
public updateCredentials(
|
|
options: Partial<{
|
|
avatar: File;
|
|
bot: boolean;
|
|
discoverable: boolean;
|
|
display_name: string;
|
|
fields_attributes: {
|
|
name: string;
|
|
value: string;
|
|
}[];
|
|
header: File;
|
|
locked: boolean;
|
|
note: string;
|
|
source: Partial<{
|
|
language: string;
|
|
privacy: string;
|
|
sensitive: boolean;
|
|
}>;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account>> {
|
|
return this.patchForm<Account>(
|
|
"/api/v1/accounts/update_credentials",
|
|
options,
|
|
extra,
|
|
);
|
|
}
|
|
|
|
// TODO: updateFilter
|
|
|
|
/**
|
|
* PUT /api/v1/lists/:id
|
|
*
|
|
* @param id Target list ID.
|
|
* @param options.title New list title.
|
|
* @param options.replies_policy Which replies should be shown in the list.
|
|
* @param options.exclusive Should the members of this list be removed from the home timeline?
|
|
* @return List.
|
|
*/
|
|
public updateList(
|
|
id: string,
|
|
options: {
|
|
title: string;
|
|
replies_policy?: "none" | "followed" | "list";
|
|
exclusive?: boolean;
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<List>> {
|
|
return this.put<List>(`/api/v1/lists/${id}`, { ...options }, extra);
|
|
}
|
|
|
|
public updateMedia(
|
|
id: string,
|
|
options?: Partial<{
|
|
description: string;
|
|
file: File;
|
|
focus: string;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Attachment>> {
|
|
return this.putForm<Attachment>(
|
|
`/api/v1/media/${id}`,
|
|
{ ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public updatePushSubscription(
|
|
data?: {
|
|
alerts: Partial<{
|
|
favourite: boolean;
|
|
follow: boolean;
|
|
mention: boolean;
|
|
poll: boolean;
|
|
reblog: boolean;
|
|
status: boolean;
|
|
follow_request: boolean;
|
|
update: boolean;
|
|
"admin.sign_up": boolean;
|
|
"admin.report": boolean;
|
|
}>;
|
|
policy?: "all" | "followed" | "follower" | "none";
|
|
},
|
|
extra?: RequestInit,
|
|
): Promise<Output<PushSubscription>> {
|
|
return this.put<PushSubscription>(
|
|
"/api/v1/push/subscription",
|
|
{ data: { ...data, policy: undefined }, policy: data?.policy },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
public uploadMedia(
|
|
file: File,
|
|
options?: Partial<{
|
|
description: string;
|
|
focus: string;
|
|
}>,
|
|
extra?: RequestInit,
|
|
): Promise<Output<Attachment | AsyncAttachment>> {
|
|
return this.postForm<Attachment | AsyncAttachment>(
|
|
"/api/v2/media",
|
|
{ file, ...options },
|
|
extra,
|
|
);
|
|
}
|
|
|
|
// TODO: userStreaming
|
|
|
|
public verifyAccountCredentials(
|
|
extra?: RequestInit,
|
|
): Promise<Output<Account>> {
|
|
return this.get<Account>("/api/v1/accounts/verify_credentials", extra);
|
|
}
|
|
|
|
public verifyAppCredentials(
|
|
extra?: RequestInit,
|
|
): Promise<Output<Application>> {
|
|
return this.get<Application>("/api/v1/apps/verify_credentials", extra);
|
|
}
|
|
|
|
public votePoll(
|
|
id: string,
|
|
choices: number[],
|
|
extra?: RequestInit,
|
|
): Promise<Output<Poll>> {
|
|
return this.post<Poll>(`/api/v1/polls/${id}/votes`, { choices }, extra);
|
|
}
|
|
}
|