@articlesq/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,736 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: "header" | "query" | "cookie";
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: "basic" | "bearer";
+    type: "apiKey" | "http";
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
+type ObjectStyle = "form" | "deepObject";
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = "connect" | "delete" | "get" | "head" | "options" | "patch" | "post" | "put" | "trace";
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit["headers"] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> & Pick<Config$1, "method" | "responseTransformer" | "responseValidator"> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit["body"];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = "data" | "fields";
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, "body" | "headers" | "method">, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T["baseUrl"];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text";
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T["throwOnError"];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, "onRequest" | "onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = ThrowOnError extends true ? Promise<TResponseStyle extends "data" ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends "data" ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & ([TData] extends [never] ? unknown : Omit<TData, "url">);
+
+type ClientOptions = {
+    baseUrl: "https://articlesq.com/api/v1" | (string & {});
+};
+type ApiError = {
+    error: {
+        title: string;
+        status: number;
+        code: ApiErrorCode;
+        message: string;
+        instance?: string;
+        details?: {
+            [key: string]: {
+                [key: string]: unknown;
+            };
+        };
+    };
+};
+type ApiErrorCode = "missing_auth" | "invalid_auth_format" | "invalid_api_key" | "api_key_expired" | "insufficient_scope" | "not_found" | "route_not_found" | "validation_failed" | "slug_conflict" | "internal_error";
+type Pagination = {
+    /**
+     * Current page number (starting from 1).
+     */
+    page: number;
+    /**
+     * Maximum number of items returned per page.
+     */
+    limit: number;
+    /**
+     * Total number of matching items.
+     */
+    total: number;
+    /**
+     * Total number of pages for the current limit.
+     */
+    totalPages: number;
+    /**
+     * Whether another page exists after the current one.
+     */
+    hasNext: boolean;
+    /**
+     * Whether another page exists before the current one.
+     */
+    hasPrev: boolean;
+};
+type FaqItem = {
+    /**
+     * The question. Plain text, no markdown.
+     */
+    q: string;
+    /**
+     * The answer. Plain text, no markdown.
+     */
+    a: string;
+};
+type Article = {
+    id: string;
+    slug: string;
+    title: string;
+    keyword: string;
+    metaDescription: string | null;
+    /**
+     * Markdown body of the article.
+     */
+    content: string;
+    /**
+     * Public URL of the generated cover image. Null while pending or if image generation failed.
+     */
+    coverImage: string | null;
+    /**
+     * Structured FAQ as plain-text Q/A pairs. Empty array when the article has no FAQ. By default the project also appends this FAQ as markdown to `content`; toggle `inlineFaqInContent` on the project (or pass `?inlineFaq=false`) to receive `content` without the FAQ section.
+     */
+    faq: Array<FaqItem>;
+    status: ArticleStatus;
+    /**
+     * Public publish date (schema.org `datePublished`) as an ISO 8601 string. Null when no specific date is set. Editable from the dashboard.
+     */
+    datePublished: string | null;
+    /**
+     * Last meaningful content update (schema.org `dateModified`) as an ISO 8601 string. Null until the article is edited after being published.
+     */
+    dateModified: string | null;
+};
+type ArticleStatus = "draft" | "published";
+type ListArticlesResponse = {
+    articles: Array<Article>;
+    pagination: Pagination;
+};
+type ArticleResponse = {
+    article: Article;
+};
+type CreateArticleBody = {
+    /**
+     * URL slug. Must be lowercase kebab-case and unique within the project.
+     */
+    slug: string;
+    /**
+     * Article title — also used as the SEO title tag.
+     */
+    title: string;
+    /**
+     * Primary keyword the article targets.
+     */
+    keyword: string;
+    /**
+     * Markdown body of the article. Defaults to an empty string when omitted — useful when creating a stub to fill in later.
+     */
+    content?: string;
+    /**
+     * SEO meta description, recommended < 155 characters.
+     */
+    metaDescription?: string;
+    /**
+     * Defaults to `draft`.
+     */
+    status?: "draft" | "published";
+    /**
+     * Structured FAQ as plain-text Q/A pairs. Server trims whitespace, drops fully-empty pairs, and rejects half-filled ones (only `q` or only `a`).
+     */
+    faq?: Array<FaqItem>;
+};
+type UpdateArticleBody = {
+    /**
+     * Article title. Empty strings are rejected.
+     */
+    title?: string;
+    /**
+     * URL-friendly slug. Empty strings are rejected. Must be unique within the project. Can only be changed while the article is in draft status.
+     */
+    slug?: string;
+    /**
+     * New markdown body. Empty strings are rejected — you can clear other fields, but the article body must stay non-empty.
+     */
+    content?: string;
+    /**
+     * SEO meta description, recommended < 155 characters.
+     */
+    metaDescription?: string;
+    /**
+     * Replace the structured FAQ. Server trims whitespace, drops fully-empty pairs, rejects half-filled ones. Pass `[]` to remove all items. Omit to leave it unchanged.
+     */
+    faq?: Array<FaqItem>;
+};
+type ListArticlesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number;
+        limit?: number;
+        /**
+         * By default only `published` articles are returned. Set to `true` to also include `draft` articles (e.g. to preview work in progress).
+         */
+        includeDrafts?: boolean;
+    };
+    url: "/articles";
+};
+type ListArticlesErrors = {
+    /**
+     * Invalid query parameters
+     */
+    400: ApiError;
+    /**
+     * Invalid or missing API key
+     */
+    401: ApiError;
+    /**
+     * API key lacks the required scope
+     */
+    403: ApiError;
+};
+type ListArticlesError = ListArticlesErrors[keyof ListArticlesErrors];
+type ListArticlesResponses = {
+    /**
+     * Articles retrieved successfully
+     */
+    200: ListArticlesResponse;
+};
+type ListArticlesResponse2 = ListArticlesResponses[keyof ListArticlesResponses];
+type CreateArticleData = {
+    body: CreateArticleBody;
+    path?: never;
+    query?: never;
+    url: "/articles";
+};
+type CreateArticleErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Invalid or missing API key
+     */
+    401: ApiError;
+    /**
+     * API key lacks the required scope
+     */
+    403: ApiError;
+    /**
+     * An article with the requested slug already exists in this project
+     */
+    409: ApiError;
+};
+type CreateArticleError = CreateArticleErrors[keyof CreateArticleErrors];
+type CreateArticleResponses = {
+    /**
+     * Article created
+     */
+    201: ArticleResponse;
+};
+type CreateArticleResponse = CreateArticleResponses[keyof CreateArticleResponses];
+type GetArticleData = {
+    body?: never;
+    path: {
+        slug: string;
+    };
+    query?: {
+        /**
+         * Whether to append the FAQ as a `## FAQ` markdown section to `content`. `true` forces inlining, `false` returns `content` without it. Omit to use the project's `inlineFaqInContent` default (on by default). The structured `faq` field is always returned either way.
+         */
+        inlineFaq?: boolean;
+        /**
+         * By default a `draft` article returns 404 on this endpoint — only `published` articles are fetchable. Set to `true` to fetch a draft (e.g. to preview work in progress).
+         */
+        includeDrafts?: boolean;
+    };
+    url: "/articles/{slug}";
+};
+type GetArticleErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: ApiError;
+    /**
+     * API key lacks the required scope
+     */
+    403: ApiError;
+    /**
+     * Article not found in this project
+     */
+    404: ApiError;
+};
+type GetArticleError = GetArticleErrors[keyof GetArticleErrors];
+type GetArticleResponses = {
+    /**
+     * Article retrieved successfully
+     */
+    200: ArticleResponse;
+};
+type GetArticleResponse = GetArticleResponses[keyof GetArticleResponses];
+type UpdateArticleData = {
+    body: UpdateArticleBody;
+    path: {
+        slug: string;
+    };
+    query?: never;
+    url: "/articles/{slug}";
+};
+type UpdateArticleErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Invalid or missing API key
+     */
+    401: ApiError;
+    /**
+     * API key lacks the required scope
+     */
+    403: ApiError;
+    /**
+     * Article not found in this project
+     */
+    404: ApiError;
+};
+type UpdateArticleError = UpdateArticleErrors[keyof UpdateArticleErrors];
+type UpdateArticleResponses = {
+    /**
+     * Article updated
+     */
+    200: ArticleResponse;
+};
+type UpdateArticleResponse = UpdateArticleResponses[keyof UpdateArticleResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+declare class Articles {
+    /**
+     * List articles
+     *
+     * Returns a paginated list of articles for the project the API key is scoped to. The article body is included for each item.
+     */
+    static listArticles<ThrowOnError extends boolean = false>(options?: Options<ListArticlesData, ThrowOnError>): RequestResult<ListArticlesResponses, ListArticlesErrors, ThrowOnError, "fields">;
+    /**
+     * Create an article
+     *
+     * Creates a new article in the project the API key is scoped to. Use this when you generate content with your own agents and want ArticlesQ to host it (e.g. for the backlinks exchange). The article body is markdown.
+     */
+    static createArticle<ThrowOnError extends boolean = false>(options: Options<CreateArticleData, ThrowOnError>): RequestResult<CreateArticleResponses, CreateArticleErrors, ThrowOnError, "fields">;
+    /**
+     * Get article by slug
+     *
+     * Returns a single article by slug, scoped to the project the API key authorises. Slugs are unique within a project.
+     */
+    static getArticle<ThrowOnError extends boolean = false>(options: Options<GetArticleData, ThrowOnError>): RequestResult<GetArticleResponses, GetArticleErrors, ThrowOnError, "fields">;
+    /**
+     * Update an article
+     *
+     * Update editable fields on an article — currently `content` and `metaDescription`. Send only the fields you want to change. Returns the full updated article.
+     */
+    static updateArticle<ThrowOnError extends boolean = false>(options: Options<UpdateArticleData, ThrowOnError>): RequestResult<UpdateArticleResponses, UpdateArticleErrors, ThrowOnError, "fields">;
+}
+
+interface ArticlesQOptions {
+    /**
+     * Your ArticlesQ API key (begins with `aq_live_`). Create one in the
+     * dashboard under **Settings → Integrations & API**.
+     */
+    apiKey: string;
+    /**
+     * Override the API base URL. Defaults to `https://articlesq.com/api/v1`.
+     * Mostly useful for staging or local development.
+     */
+    baseUrl?: string;
+}
+/**
+ * Official TypeScript SDK for the ArticlesQ API.
+ *
+ * @example
+ * ```ts
+ * import { ArticlesQ } from "@articlesq/sdk";
+ *
+ * const articlesq = new ArticlesQ({ apiKey: process.env.ARTICLESQ_API_KEY! });
+ *
+ * const { data } = await articlesq.articles.list({ page: 1, limit: 20 });
+ * if (data) {
+ *   for (const article of data.articles) {
+ *     console.log(article.title);
+ *   }
+ * }
+ * ```
+ */
+declare class ArticlesQ {
+    /**
+     * Article resources — list and fetch articles for the project this API
+     * key is scoped to.
+     */
+    readonly articles: ReturnType<typeof createArticlesNamespace>;
+    constructor(options: ArticlesQOptions);
+}
+declare function createArticlesNamespace(client: Client): {
+    /** List articles in the current project. Wraps `Articles.listArticles`. */
+    list: (query?: ListArticlesData["query"]) => Promise<({
+        data: ListArticlesResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: ApiError;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>;
+    /** Fetch a single article by slug. Wraps `Articles.getArticle`. */
+    get: (slug: string, query?: GetArticleData["query"]) => Promise<({
+        data: ArticleResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: ApiError;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>;
+    /**
+     * Create a new article in the current project. Wraps `Articles.createArticle`.
+     *
+     * Use this when you generate content with your own agents and want
+     * ArticlesQ to host it (e.g. for the backlinks exchange). The body
+     * is markdown.
+     *
+     * Slugs are unique within a project — reusing one returns 409
+     * `slug_conflict` in the error channel.
+     */
+    create: (body: CreateArticleData["body"]) => Promise<({
+        data: ArticleResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: ApiError;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>;
+    /**
+     * Update editable fields on an article. Wraps `Articles.updateArticle`.
+     *
+     * Send only the fields you want to change (currently `content` and
+     * `metaDescription`). Returns the full updated article on success.
+     */
+    update: (slug: string, body: UpdateArticleData["body"]) => Promise<({
+        data: ArticleResponse;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: ApiError;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>;
+};
+
+export { type ApiError, type ApiErrorCode, type Article, type ArticleResponse, type ArticleStatus, Articles, ArticlesQ, type ArticlesQOptions, type ClientOptions, type CreateArticleBody, type CreateArticleData, type CreateArticleError, type CreateArticleErrors, type CreateArticleResponse, type CreateArticleResponses, type FaqItem, type GetArticleData, type GetArticleError, type GetArticleErrors, type GetArticleResponse, type GetArticleResponses, type ListArticlesData, type ListArticlesError, type ListArticlesErrors, type ListArticlesResponse, type ListArticlesResponse2, type ListArticlesResponses, type Options, type Pagination, type UpdateArticleBody, type UpdateArticleData, type UpdateArticleError, type UpdateArticleErrors, type UpdateArticleResponse, type UpdateArticleResponses, ArticlesQ as default };