import type { ReturnCache } from '../cache';
import { type AnonymousGuildStructure, type GuildStructure, type UserStructure, type WebhookMessageStructure, type WebhookStructure } from '../client/transformers';
import type { UsingClient } from '../commands';
import type { ImageOptions, MessageWebhookCreateBodyRequest, MessageWebhookPayload, MessageWebhookUpdateBodyRequest, MethodContext, ObjectToLower, WebhookShorterMessageDeleteParams, WebhookShorterMessageFetchParams } from '../common';
/**
 * Represents a Discord webhook.
 */
import type { APIWebhook, RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPatchAPIWebhookWithTokenMessageQuery, RESTPostAPIWebhookWithTokenQuery } from '../types';
import type { AllChannels } from './channels';
import { DiscordBase } from './extra/DiscordBase';
export interface Webhook extends DiscordBase, ObjectToLower<Omit<APIWebhook, 'user' | 'source_guild'>> {
}
/**
 * Represents a Discord webhook.
 */
export declare class Webhook extends DiscordBase {
    /** The user associated with the webhook, if applicable. */
    user?: UserStructure;
    /** The source guild of the webhook, if applicable. */
    sourceGuild?: Partial<AnonymousGuildStructure>;
    /** Methods related to interacting with messages through the webhook. */
    messages: ReturnType<typeof Webhook.messages>;
    /**
     * Constructs a new Webhook instance.
     * @param client The Discord client instance.
     * @param data The data representing the webhook.
     */
    constructor(client: UsingClient, data: APIWebhook);
    /**
     * Fetches the guild associated with the webhook.
     * @param force Whether to force fetching the guild even if it's already cached.
     * @returns A promise that resolves to the guild associated with the webhook, or undefined if not applicable.
     */
    guild(mode?: 'rest' | 'flow'): Promise<GuildStructure<'cached' | 'api'> | undefined>;
    guild(mode: 'cache'): ReturnCache<GuildStructure<'cached'> | undefined>;
    /**
     * Fetches the channel associated with the webhook.
     * @param force Whether to force fetching the channel even if it's already cached.
     * @returns A promise that resolves to the channel associated with the webhook, or undefined if not applicable.
     */
    channel(mode?: 'rest' | 'flow'): Promise<AllChannels>;
    channel(mode: 'cache'): ReturnCache<AllChannels | undefined>;
    /**
     * Retrieves the avatar URL of the webhook.
     * @param options The image options for the avatar.
     * @returns The avatar URL of the webhook, or null if no avatar is set.
     */
    avatarURL(options?: ImageOptions): string | null;
    /**
     * Fetches the webhook data from the Discord API.
     * @returns A promise that resolves to the fetched webhook data.
     */
    fetch(): Promise<WebhookStructure>;
    /**
     * Edits the webhook.
     * @param body The new webhook data.
     * @param reason The reason for editing the webhook.
     * @returns A promise that resolves when the webhook is successfully edited.
     */
    edit(body: RESTPatchAPIWebhookJSONBody | RESTPatchAPIWebhookWithTokenJSONBody, reason?: string): Promise<WebhookStructure>;
    /**
     * Deletes the webhook.
     * @param reason The reason for deleting the webhook.
     * @returns A promise that resolves when the webhook is successfully deleted.
     */
    delete(reason?: string): Promise<undefined>;
    /**
     * Static methods related to interacting with messages through webhooks.
     */
    static messages({ client, webhookId, webhookToken }: MethodContext<{
        webhookId: string;
        webhookToken: string;
    }>): {
        /** Writes a message through the webhook. */
        write: {
            (payload: MessageWebhookMethodWriteWaitParams): Promise<WebhookMessageStructure>;
            (payload: MessageWebhookMethodWriteParams): Promise<WebhookMessageStructure | null>;
        };
        /** Edits a message sent through the webhook. */
        edit: (payload: MessageWebhookMethodEditParams) => Promise<WebhookMessageStructure>;
        /** Deletes a message sent through the webhook. */
        delete: (payload: MessageWebhookMethodDeleteParams) => Promise<undefined>;
        fetch: (payload: MessageWebhookMethodFetchParams) => Promise<WebhookMessageStructure>;
    };
    /**
     * Static methods related to managing webhooks.
     */
    static methods({ client, webhookId, webhookToken }: MethodContext<{
        webhookId: string;
        webhookToken?: string;
    }>): {
        /** Deletes the webhook. */
        delete: (reason?: string) => Promise<undefined>;
        /** Edits the webhook. */
        edit: (body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, reason?: string) => Promise<Webhook>;
        /** Fetches the webhook data from the Discord API. */
        fetch: () => Promise<Webhook>;
    };
}
/** Type definition for parameters of editing a message through a webhook. */
export type MessageWebhookMethodEditParams = MessageWebhookPayload<MessageWebhookUpdateBodyRequest, {
    messageId: string;
    query?: RESTPatchAPIWebhookWithTokenMessageQuery;
}>;
/** Type definition for parameters of writing a message through a webhook. */
export type MessageWebhookMethodWriteParams = MessageWebhookPayload<MessageWebhookCreateBodyRequest, {
    query?: RESTPostAPIWebhookWithTokenQuery;
}>;
export type MessageWebhookMethodWriteWaitParams = MessageWebhookPayload<MessageWebhookCreateBodyRequest, {
    query: RESTPostAPIWebhookWithTokenQuery & {
        wait: true;
    };
}>;
export type MessageWebhookMethodDeleteParams = Omit<WebhookShorterMessageDeleteParams, 'token' | 'webhookId'>;
export type MessageWebhookMethodFetchParams = Omit<WebhookShorterMessageFetchParams, 'token' | 'webhookId'>;