@omelhorsite/sdk 0.13.0 → 0.16.0

package/dist/types/auth/tokens.d.ts

@@ -93,7 +93,7 @@ export interface TokenStore {
  * narrowest set the product actually uses: every extra scope makes the
  * approval page scarier for no benefit.
  */
-export declare const OMS_SCOPES: readonly ["openid", "profile", "email", "tools:read", "tools:write", "storage:read", "storage:write", "tickets:write"];
+export declare const OMS_SCOPES: readonly ["openid", "profile", "email", "tools:read", "tools:write", "storage:read", "storage:write", "tickets:write", "llm", "blogs:read", "blogs:write", "news:read", "news:write", "cron:read", "cron:write"];
 /** One of {@link OMS_SCOPES}. */
 export type OmsScope = (typeof OMS_SCOPES)[number];
 /** Refresh this long before the real expiry unless the host says otherwise. */

package/dist/types/client.d.ts

@@ -19,6 +19,7 @@ import { PasskeysNamespace } from "./resources/auth/passkeys";
 import { AuthSessionsNamespace } from "./resources/auth/sessions";
 import { ChestsNamespace } from "./resources/chests";
 import { ContentNamespace } from "./resources/content";
+import { CronNamespace } from "./resources/cron";
 import { DynamicQrsNamespace } from "./resources/dynamicQrs";
 import { FormsNamespace } from "./resources/forms";
 import { IpLookupNamespace } from "./resources/ipLookup";
@@ -183,6 +184,8 @@ export declare class Oms {
     readonly search: SearchNamespace;
     /** The language models the signed-in person may pick, and their own usage. */
     readonly llm: LlmNamespace;
+    /** TypeScript scripts the server runs on a schedule as the signed-in person. */
+    readonly cron: CronNamespace;
     /**
      * The WebSocket connection: playback handoff, jams, notifications, job
      * progress. Opens nothing until {@link RealtimeNamespace.connect} is called,

package/dist/types/resources/admin/llm.d.ts

@@ -117,6 +117,12 @@ export interface LlmModel {
     readonly enabled: boolean;
     /** Whether signed-in people may pick it (see `oms.llm.models`). */
     readonly visible_in_chat: boolean;
+    /**
+     * Who may pick it by name: `0` everyone, `1` trusted accounts, `2`
+     * administrators. An account reaches the models at or below its own tier
+     * (`oms.admin.quotas.setLlmTier`).
+     */
+    readonly tier: number;
     readonly context_window: number | null;
     readonly max_output_tokens: number | null;
     readonly input_price_per_million: number | null;
@@ -134,6 +140,8 @@ export interface CreateLlmModelInput {
     readonly name: string;
     readonly enabled?: boolean;
     readonly visibleInChat?: boolean;
+    /** `0` to `2`; see {@link LlmModel.tier}. */
+    readonly tier?: number;
     readonly contextWindow?: number | null;
     readonly maxOutputTokens?: number | null;
     readonly inputPricePerMillion?: number | null;
@@ -145,7 +153,7 @@ export interface CreateLlmModelInput {
 /** The provider and the `model_id` are fixed after creation. */
 export type UpdateLlmModelInput = Partial<Omit<CreateLlmModelInput, "llmProviderId" | "modelId">>;
 /** Filter columns of `GET /admin/llm_models`. */
-export declare const ADMIN_LLM_MODEL_FILTER_COLUMNS: readonly ["llm_provider_id", "model_id", "name", "enabled", "visible_in_chat", "free"];
+export declare const ADMIN_LLM_MODEL_FILTER_COLUMNS: readonly ["llm_provider_id", "model_id", "name", "enabled", "visible_in_chat", "tier", "free"];
 export interface ListAdminLlmModelsParams extends ListParams<(typeof ADMIN_LLM_MODEL_FILTER_COLUMNS)[number]> {
 }
 /**

package/dist/types/resources/admin/quotas.d.ts

@@ -54,6 +54,11 @@ export interface AdminUserQuotaEntry {
 export interface AdminUserQuotas {
     readonly user_id: Id;
     readonly handle: string;
+    /**
+     * Which language models the person may pick by name: every model whose
+     * `tier` is at or below this. `0` for a new account. See {@link AdminQuotasNamespace.setLlmTier}.
+     */
+    readonly llm_tier: number;
     /**
      * **Every** resource in the catalogue, including the storage and music
      * ceilings. Unlike the anonymous answer from `oms.quotas.list()`, nothing is
@@ -111,4 +116,13 @@ export declare class AdminQuotasNamespace extends Resource {
      * @throws {OmsAuthError} 403 for a non-admin.
      */
     update(user: Id | string, overrides: readonly AdminQuotaOverride[], options?: RequestOptions): Promise<AdminUserQuotas>;
+    /**
+     * `PUT /admin/users/:user/quotas` with `llm_tier` only - which language
+     * models the person may pick by name (`0` everyone's, `1` adds the trusted
+     * ones, `2` adds the administrators' ones). Quota overrides are untouched.
+     *
+     * @throws {OmsApiError} 400 for a tier outside `0..2`; 404 `"User not found"`.
+     * @throws {OmsAuthError} 403 for a non-admin.
+     */
+    setLlmTier(user: Id | string, tier: number, options?: RequestOptions): Promise<AdminUserQuotas>;
 }

package/dist/types/resources/content/blogs.d.ts

@@ -13,7 +13,19 @@ export interface BlogAuthor {
     readonly name: string;
 }
 /**
- * A blog: one per user, created lazily.
+ * Who can read a blog.
+ *
+ * - `"public"`: listed on the discovery feed and open to everyone;
+ * - `"unlisted"`: open to anyone who has the link, never listed;
+ * - `"private"`: the owner, administrators and the invited members only.
+ *   Anonymous readers get `401`, signed-in strangers `403` with
+ *   `error: "private"`.
+ */
+export declare const BLOG_VISIBILITIES: readonly ["public", "unlisted", "private"];
+export type BlogVisibility = (typeof BLOG_VISIBILITIES)[number];
+/**
+ * A blog. A person may own several; the oldest is their default one (the one
+ * `mine` answers and posts land in when no blog is named).
  *
  * Deliberately NOT a `BaseRecord`: the payload has `created_at` and NO
  * `updated_at`. Do not reach for one.
@@ -23,15 +35,23 @@ export interface Blog {
     /**
      * URL-safe handle of the blog, and the ONLY way to address it on the read
      * routes. Matches `/\A[a-z0-9][a-z0-9_-]*\z/`, 1-64 characters, unique
-     * across the whole table. Defaults to the owner's handle, lowercased.
+     * across the whole table. Defaults to the owner's handle, lowercased, with
+     * a numeric suffix for each further blog created without a slug.
      */
     readonly slug: string;
     /** Display name. Defaults to `"<name>'s blog"`. Up to 80 characters. */
     readonly name: string;
     /** Up to 240 characters, or `null`. */
     readonly description: string | null;
-    /** Who owns it. One blog per user, enforced by a unique index on `user_id`. */
+    /** Who owns it. */
     readonly user: BlogAuthor;
+    readonly visibility: BlogVisibility | string;
+    /** Invited members (private blogs). Counted live. */
+    readonly members_count: number;
+    /** Whether the CALLING user owns it. Per-viewer, like `is_following`. */
+    readonly is_owner: boolean;
+    /** Whether the CALLING user is an invited member. Per-viewer. */
+    readonly is_member: boolean;
     /**
      * Subscribers with a `confirmed_at`, counted live on every render.
      *
@@ -79,11 +99,14 @@ export interface BlogPostSummary {
     readonly reading_minutes: number;
     /** Lowercased, de-duplicated, at most 10. Never `null` in the payload. */
     readonly tags: string[];
-    /** The blog it belongs to, trimmed to three fields. */
+    /** `"user"` when written in the editor, `"api"` when a program posted it with an access token. */
+    readonly source: "user" | "api" | string;
+    /** The blog it belongs to, trimmed to four fields. */
     readonly blog: {
         readonly id: BlogId;
         readonly slug: string;
         readonly name: string;
+        readonly visibility: BlogVisibility | string;
     };
 }
 /** A post with its body: the `:extended` view, returned by every single-post route. */
@@ -130,6 +153,64 @@ export interface UpdateBlogInput {
     readonly name?: string;
     /** Up to 240 characters. */
     readonly description?: string | null;
+    readonly visibility?: BlogVisibility;
+}
+/** Arguments for {@link OwnBlogsNamespace.create}. Everything is optional: the defaults are the same as the first blog's. */
+export interface CreateBlogInput {
+    readonly slug?: string;
+    readonly name?: string;
+    readonly description?: string | null;
+    /** Defaults to `"public"`. */
+    readonly visibility?: BlogVisibility;
+}
+/** An invited member of one of the caller's blogs. Being a member also subscribes the person to the blog's news. */
+export interface BlogMember {
+    readonly id: number;
+    readonly blog_id: BlogId;
+    readonly user: BlogAuthor;
+    readonly created_at: Timestamp;
+}
+/** At most this many blogs per account; creating one more answers `400`. */
+export declare const BLOGS_PER_ACCOUNT = 20;
+/**
+ * The caller's own blogs, reachable as `oms.content.blogs.own`. Needs the
+ * `blogs:read` scope to read and `blogs:write` to change anything.
+ *
+ * A blog is addressed by its numeric id or its slug on every route here.
+ */
+export declare class OwnBlogsNamespace extends Resource {
+    /** `GET /my_blogs` - every blog the caller owns, oldest first. The first one is the default. */
+    list(options?: RequestOptions): Promise<Blog[]>;
+    /**
+     * `GET /my_blogs/:id` - one of the caller's blogs with ALL of its posts,
+     * drafts included, newest first.
+     *
+     * @throws {OmsApiError} 404 `"Blog not found"` for a blog the caller does not own.
+     */
+    get(idOrSlug: BlogId | string, options?: RequestOptions): Promise<BlogWithPosts>;
+    /**
+     * `POST /my_blogs` - a further blog. Without a slug the server takes the
+     * handle with a numeric suffix.
+     *
+     * @throws {OmsApiError} 400 with the validation sentence (taken or
+     *   malformed slug, unknown visibility) or `"blog limit reached (20)"`.
+     */
+    create(input?: CreateBlogInput, options?: RequestOptions): Promise<Blog>;
+    /** `PATCH /my_blogs/:id` - name, slug, description or visibility. Re-slugging breaks published links. */
+    update(idOrSlug: BlogId | string, input: UpdateBlogInput, options?: RequestOptions): Promise<Blog>;
+    /** `DELETE /my_blogs/:id` - the blog and every post, subscriber and member in it. */
+    delete(idOrSlug: BlogId | string, options?: RequestOptions): Promise<void>;
+    /** `GET /my_blogs/:id/members` - the invited members, oldest first. */
+    members(idOrSlug: BlogId | string, options?: RequestOptions): Promise<BlogMember[]>;
+    /**
+     * `POST /my_blogs/:id/members` - invites a person of the site by handle (a
+     * leading `@` is fine). Idempotent: inviting twice answers the same member.
+     *
+     * @throws {OmsApiError} 404 `"User not found"`; 400 when the handle is the owner's own.
+     */
+    addMember(idOrSlug: BlogId | string, handle: string, options?: RequestOptions): Promise<BlogMember>;
+    /** `DELETE /my_blogs/:id/members/:member` - by member id or by the member's user id. Their subscription goes too. */
+    removeMember(idOrSlug: BlogId | string, memberOrUserId: number | Id, options?: RequestOptions): Promise<void>;
 }
 /** Result of a subscribe call. */
 export interface BlogSubscribeResult {
@@ -166,6 +247,8 @@ export interface BlogSubscribeResult {
 export declare class BlogsNamespace extends Resource {
     /** Posts, blog metadata and publishing. Also mounted as `oms.blogPosts`. */
     readonly posts: BlogPostsNamespace;
+    /** The caller's own blogs: create more, change visibility, invite members. */
+    readonly own: OwnBlogsNamespace;
     constructor(http: ApiClient);
     /**
      * `GET /blogs` - the discovery feed: the 30 most recent PUBLISHED posts
@@ -291,6 +374,11 @@ export declare class BlogsNamespace extends Resource {
 }
 /** Arguments for {@link BlogPostsNamespace.create}. */
 export interface CreateBlogPostInput {
+    /** Which of the caller's blogs gets the post. Omit both for the default (oldest) blog. */
+    readonly blogId?: BlogId;
+    readonly blogSlug?: string;
+    /** Publish at once instead of saving a draft. */
+    readonly publish?: boolean;
     /** Required, up to 200 characters. */
     readonly title: string;
     /**
@@ -379,45 +467,37 @@ export declare class BlogPostsNamespace extends Resource {
     get(id: BlogPostId, options?: RequestOptions): Promise<BlogPost>;
     /**
      * `GET /blogs/:blogSlug/posts/:slug` - one post by the pair of slugs, which
-     * is the shape a public permalink has.
-     *
-     * **This route needs a session, and the id route does not.** That is almost
-     * certainly a mistake in the backend and it is worth knowing before you
-     * build a public permalink on it: an anonymous reader following a shared
-     * link gets `401 "Session required to access this resource."` here, while
-     * {@link get} hands them the very same published post. Until that is fixed,
-     * render public permalinks through {@link get} with the numeric id, or
-     * expect signed-in readers only.
-     *
-     * Both slugs are lowercased server-side before the lookup. The route is
-     * declared with `constraints: { blog_slug: /[^\/]+/, slug: /[^\/]+/ }`, so a
-     * slug containing a slash cannot reach it at all - not a concern for
+     * is the shape a public permalink has. Open to anonymous readers for a
+     * published post of a public or unlisted blog.
+     *
+     * Both slugs are lowercased server-side before the lookup. A slug
+     * containing a slash cannot reach the route at all - not a concern for
      * server-minted slugs, which are `[a-z0-9_-]` only.
      *
-     * @throws {OmsApiError} 401 without a session, before anything else is
-     *   checked; 404 `"Blog not found"` or `"Post not found"`; 401
-     *   `"Draft only visible to author"`.
+     * @throws {OmsApiError} 404 `"Blog not found"` or `"Post not found"`; 401
+     *   `"Draft only visible to author"`; for a private blog, 401 without a
+     *   session and 403 `error: "private"` with one.
      */
     getBySlugs(blogSlug: string, slug: string, options?: RequestOptions): Promise<BlogPost>;
     /**
-     * `POST /blog_posts` - writes a new post to the caller's own blog. `201`.
+     * `POST /blog_posts` - writes a new post. `201`.
      *
-     * There is no blog argument because there is no choice: the controller calls
-     * `Blog.find_or_create_for(Current.user)`, so this CREATES the caller's blog
-     * as a side effect on their very first post, exactly like
-     * {@link BlogsNamespace.mine}.
+     * `blogId` or `blogSlug` picks one of the caller's own blogs; with neither
+     * the post lands in the default (oldest) blog, which is created on the spot
+     * if the caller has none yet, exactly like {@link BlogsNamespace.mine}.
      *
-     * The post starts as a DRAFT - `published_at` is not settable here and no
-     * amount of arguments will publish it. Publishing is a second call, and it
-     * is {@link setPublished}, not {@link update}.
+     * The post starts as a DRAFT unless `publish: true` is sent, which stamps
+     * `published_at` at once. Later changes to the flag go through
+     * {@link setPublished}, not {@link update}. A post written with an access
+     * token carries `source: "api"`.
      *
      * Rides the general ceiling: there is no per-user cap on how many posts may
      * be created, and no length cap beyond the model's 200 000 characters of
-     * markdown.
+     * markdown. Needs the `blogs:write` scope on an OAuth token.
      *
      * @throws {OmsApiError} 401 `"Session required to access this resource."`;
-     *   400 with the validation sentence, most often the slug already existing
-     *   in this blog.
+     *   404 `"Blog not found"` for a blog the caller does not own; 400 with the
+     *   validation sentence, most often the slug already existing in this blog.
      */
     create(input: CreateBlogPostInput, options?: RequestOptions): Promise<BlogPost>;
     /**

package/dist/types/resources/content/index.d.ts

@@ -3,7 +3,7 @@ import { type ApiClient, Resource } from "../../http";
 import { AnalysisNamespace } from "./analysis";
 import { BlogsNamespace } from "./blogs";
 import { FeedbacksNamespace } from "./feedbacks";
-import { IntelNamespace } from "./intel/index";
+import { NewsNamespace } from "./news/index";
 import { JokesNamespace } from "./jokes";
 import { NotificationsNamespace } from "./notifications";
 import { ServiceUsagesNamespace } from "./serviceUsages";
@@ -13,7 +13,7 @@ import { SpaceInvadersNamespace } from "./spaceInvaders";
 export * from "./analysis";
 export * from "./blogs";
 export * from "./feedbacks";
-export * from "./intel/index";
+export * from "./news/index";
 export * from "./jokes";
 export * from "./notifications";
 export * from "./serviceUsages";
@@ -46,7 +46,7 @@ export declare class ContentNamespace extends Resource {
     readonly analysis: AnalysisNamespace;
     /** The Space Invaders leaderboard. */
     readonly spaceInvaders: SpaceInvadersNamespace;
-    /** Intel: articles, reports, sources, scripts, items, config and stats. See {@link IntelNamespace}. */
-    readonly intel: IntelNamespace;
+    /** News: feeds, sources, scripts and the items they produce. See {@link NewsNamespace}. */
+    readonly news: NewsNamespace;
     constructor(http: ApiClient);
 }

package/dist/types/resources/content/news/feeds.d.ts

@@ -0,0 +1,56 @@
+/** News feeds: the named sets of sources a person follows. */
+import { Resource } from "../../../http";
+import type { ListParams } from "../../../listing";
+import type { Id, Paginated, RequestOptions, Timestamp } from "../../../types";
+/** At most this many feeds per account; one more is a `400`. */
+export declare const NEWS_FEEDS_PER_ACCOUNT = 10;
+/** `retention_days` outside this range is a `400`. */
+export declare const NEWS_FEED_MIN_RETENTION_DAYS = 7;
+export declare const NEWS_FEED_MAX_RETENTION_DAYS = 3650;
+/**
+ * A feed: a named set of {@link NewsSource}s and the {@link NewsItem}s they
+ * produce. Several per account, unique by name; the oldest is the default
+ * one a source lands in when it names no feed.
+ */
+export interface NewsFeed {
+    readonly id: Id;
+    readonly created_at: Timestamp;
+    readonly updated_at: Timestamp;
+    /** Up to 80 characters, whitespace-squished, unique per account. */
+    readonly name: string;
+    /** Up to 500 characters. */
+    readonly description: string | null;
+    /** Items older than this are pruned. Default 90. */
+    readonly retention_days: number;
+    /** A disabled feed's sources are not polled. */
+    readonly enabled: boolean;
+}
+/** `GET /news_feeds/:id` adds two live counters. */
+export interface NewsFeedDetail extends NewsFeed {
+    readonly sources_count: number;
+    readonly items_count: number;
+}
+/** Filter columns of `GET /news_feeds`, on top of {@link BASE_FILTER_COLUMNS}. */
+export declare const NEWS_FEED_FILTER_COLUMNS: readonly ["name", "enabled"];
+export interface ListNewsFeedsParams extends ListParams<(typeof NEWS_FEED_FILTER_COLUMNS)[number]> {
+}
+export interface CreateNewsFeedInput {
+    readonly name: string;
+    readonly description?: string | null;
+    readonly retentionDays?: number;
+    readonly enabled?: boolean;
+}
+export type UpdateNewsFeedInput = Partial<CreateNewsFeedInput>;
+/** `/news_feeds` - your feeds. Needs `news:read` to read and `news:write` to change. */
+export declare class NewsFeedsNamespace extends Resource {
+    /** `GET /news_feeds` - your feeds, oldest first. */
+    list(params?: ListNewsFeedsParams, options?: RequestOptions): Promise<Paginated<NewsFeed>>;
+    /** `GET /news_feeds/:id` - one feed with its counters. 404 when it is not yours. */
+    get(id: Id, options?: RequestOptions): Promise<NewsFeedDetail>;
+    /** `POST /news_feeds`. `201`. 400 for a duplicate name or past the cap. */
+    create(input: CreateNewsFeedInput, options?: RequestOptions): Promise<NewsFeed>;
+    /** `PATCH /news_feeds/:id`. */
+    update(id: Id, input: UpdateNewsFeedInput, options?: RequestOptions): Promise<NewsFeed>;
+    /** `DELETE /news_feeds/:id` - the feed, its sources and every item. `204`. */
+    delete(id: Id, options?: RequestOptions): Promise<void>;
+}

package/dist/types/resources/content/news/index.d.ts

@@ -0,0 +1,36 @@
+/** The `news` namespace and everything under it. */
+import { type ApiClient, Resource } from "../../../http";
+import { NewsFeedsNamespace } from "./feeds";
+import { NewsItemsNamespace } from "./items";
+import { NewsScriptsNamespace } from "./scripts";
+import { NewsSourcesNamespace } from "./sources";
+export * from "./feeds";
+export * from "./items";
+export * from "./scripts";
+export * from "./sources";
+/**
+ * The `news` namespace, reachable as `oms.content.news`: the ingestion side
+ * of following the web.
+ *
+ * 1. a {@link NewsScript} knows HOW to fetch one kind of source (RSS, a
+ *    Telegram channel, a YouTube channel, a page with a selector);
+ * 2. a {@link NewsSource} is that script plus its settings, inside a
+ *    {@link NewsFeed} - a named set of sources;
+ * 3. polling a source writes {@link NewsItem} rows: raw, one per thing the
+ *    source published, full-text searchable and readable incrementally.
+ *
+ * Open to every account within its quotas (`news_sources` in
+ * `oms.quotas.list()`). Needs the `news:read` and `news:write` scopes on an
+ * OAuth token. Ids are strings throughout.
+ */
+export declare class NewsNamespace extends Resource {
+    /** Named sets of sources. Full CRUD. */
+    readonly feeds: NewsFeedsNamespace;
+    /** The sources you follow. Full CRUD, plus a manual run. */
+    readonly sources: NewsSourcesNamespace;
+    /** The fetchers. Full CRUD over yours; the built-ins are read-only. */
+    readonly scripts: NewsScriptsNamespace;
+    /** What the sources produced. Read plus delete. */
+    readonly items: NewsItemsNamespace;
+    constructor(http: ApiClient);
+}

package/dist/types/resources/content/news/items.d.ts

@@ -0,0 +1,115 @@
+/** News items: what the sources produced, raw. */
+import { Resource } from "../../../http";
+import type { ListParams } from "../../../listing";
+import type { Id, Paginated, RequestOptions, Timestamp } from "../../../types";
+/**
+ * A raw item, exactly as a script returned it.
+ *
+ * Written only by the ingest job; over HTTP it is read-only plus a delete.
+ * Items are the substrate everything downstream (a report, a story, a cron
+ * script) is built from - nothing copies the body, it points here.
+ */
+export interface NewsItem {
+    readonly id: Id;
+    readonly created_at: Timestamp;
+    readonly updated_at: Timestamp;
+    /** The feed the source belonged to when the item was written. */
+    readonly news_feed_id: Id;
+    /** Which source produced it. */
+    readonly news_source_id: Id;
+    /**
+     * The script's own id for this item, unique per source. This is the
+     * de-duplication key: a second poll that returns the same `external_id` does
+     * not create a second row.
+     */
+    readonly external_id: string;
+    readonly title: string | null;
+    /** The body the script extracted. Can be large; a listing carries all of it. */
+    readonly content: string | null;
+    readonly url: string | null;
+    readonly author: string | null;
+    /** Publication time as the feed reported it, not as we saw it. */
+    readonly published_at: Timestamp | null;
+    /** When the poll that produced this item ran. Never null. */
+    readonly fetched_at: Timestamp;
+    /**
+     * Set when the item is a VIDEO the script discovered (YouTube, RTP Play):
+     * the server downloads the audio, transcribes it and splits it into news
+     * items. The video row itself stays as it is; the news it yields are child
+     * items pointing back via {@link parent_id}.
+     */
+    readonly media_url: string | null;
+    /**
+     * Transcription state of a video row: `pending` → `processing` →
+     * `transcribed` (the `content` now holds the `[m:ss] text` transcript) →
+     * `done`, or `failed` with {@link media_error}. `null` on non-video items.
+     */
+    readonly media_status: NewsMediaStatus | null;
+    readonly media_error: string | null;
+    /** On a news item cut from a video: the video (parent) item's id. */
+    readonly parent_id: Id | null;
+    /** On a news item cut from a video: where in the video it starts, in seconds. */
+    readonly media_offset_s: number | null;
+}
+/** Lifecycle of a video item's transcription. */
+export type NewsMediaStatus = "pending" | "processing" | "transcribed" | "done" | "failed";
+/** Filter columns of `GET /news_items`, on top of {@link BASE_FILTER_COLUMNS}. */
+export declare const NEWS_ITEM_FILTER_COLUMNS: readonly ["news_feed_id", "news_source_id", "external_id", "title", "content", "url", "media_status", "parent_id"];
+/** Filters for {@link NewsItemsNamespace.list}. */
+export interface ListNewsItemsParams extends ListParams<(typeof NEWS_ITEM_FILTER_COLUMNS)[number]> {
+    /** Only items of one feed. Sent as `exact_search[news_feed_id]`. */
+    readonly feedId?: Id;
+    /** Only items produced by one source. Sent as `exact_search[news_source_id]`. */
+    readonly sourceId?: Id;
+    /**
+     * Full-text search over title and body, in Portuguese (stemmed, so
+     * `mesquitas` finds `mesquita`). Web-search syntax: quotes for a phrase,
+     * `-` to exclude, `or` between words. Results come by relevance when this
+     * is set, whatever `order` says.
+     */
+    readonly query?: string;
+    /** Only items written at or after this instant (ISO 8601). The incremental read a script wants. */
+    readonly since?: string;
+    /** Only items written at or before this instant (ISO 8601). */
+    readonly until?: string;
+}
+/**
+ * `/news_items` - the raw material.
+ *
+ * Read-only plus a delete: items are written by the ingest job and by
+ * nothing else.
+ */
+export declare class NewsItemsNamespace extends Resource {
+    /**
+     * `GET /news_items` - raw items, newest first.
+     *
+     * **Heavy.** Every row carries {@link NewsItem.content} in full - the whole
+     * article text a script scraped - and there is no lighter view. The SDK
+     * defaults to a page of 25 for that reason; raising it is how you get a
+     * multi-megabyte response.
+     *
+     * For an incremental reader, remember the newest `created_at` you saw and
+     * pass it back as `since` with `order: "created_at:asc"`.
+     *
+     * The controller sets no ordering; the SDK sends `created_at:desc`.
+     *
+     * @throws {OmsApiError} 400 when `since` or `until` is not ISO 8601.
+     */
+    list(params?: ListNewsItemsParams, options?: RequestOptions): Promise<Paginated<NewsItem>>;
+    /**
+     * `GET /news_items/:id` - one raw item. Same shape a listing row has.
+     *
+     * @throws {OmsApiError} 404 when the item is not yours.
+     */
+    get(id: Id, options?: RequestOptions): Promise<NewsItem>;
+    /**
+     * `DELETE /news_items/:id`. `204`, empty body.
+     *
+     * Rarely what you want. The item's `external_id` uniqueness is what stops the
+     * next poll re-fetching it, so deleting one invites it straight back on the
+     * following run. Delete the SOURCE, or leave items alone.
+     *
+     * @throws {OmsApiError} 404 when the item is not yours.
+     */
+    delete(id: Id, options?: RequestOptions): Promise<void>;
+}