@taktoria/sdk 0.0.0-stage → 0.1.0

package/dist/cjs/api/resources/mcpConnections/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./McpConnection.js";
+export * from "./McpConnectionClient.js";
+export * from "./McpConnectionPage.js";
+export * from "./McpConnectionPerson.js";
+export * from "./McpConnectionSettings.js";
+export * from "./UpdateMcpConnectionSettingsRequest.js";

package/dist/cjs/api/resources/mcpConnections/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./McpConnection.js"), exports);
+__exportStar(require("./McpConnectionClient.js"), exports);
+__exportStar(require("./McpConnectionPage.js"), exports);
+__exportStar(require("./McpConnectionPerson.js"), exports);
+__exportStar(require("./McpConnectionSettings.js"), exports);
+__exportStar(require("./UpdateMcpConnectionSettingsRequest.js"), exports);

package/dist/cjs/api/resources/memegen/client/Client.d.ts

@@ -0,0 +1,446 @@
+import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
+import { type NormalizedClientOptionsWithAuth } from "../../../../BaseClient.js";
+import * as core from "../../../../core/index.js";
+import * as Taktoria from "../../../index.js";
+export declare namespace MemegenClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+export declare class MemegenClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<MemegenClient.Options>;
+    constructor(options: MemegenClient.Options);
+    /**
+     * The gallery: Recent (`sort=newest`, the default) or Popular
+     * (`sort=top`, most upvoted first, newest breaking ties), optionally
+     * within a `window`. `mine=true` is My memes, a signed-in session's
+     * own; a key acts for the workspace and has none, so it is refused
+     * (`403 forbidden`) and filters by `authorId` instead.
+     *
+     * @param {Taktoria.ListMemesRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.UnauthorizedError}
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.listMemes()
+     */
+    listMemes(request?: Taktoria.ListMemesRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemePage>;
+    private __listMemes;
+    /**
+     * Made by the app's rules, whoever asks: the template must be in the
+     * workspace and not archived, the captions are folded, cut at 140
+     * characters and fitted to the layout's boxes (padded or trimmed), a
+     * meme with no words is refused with `422`, a `layout` equal to the
+     * template's is not stored, and the meme appears in the workspace's
+     * activity. A signed-in session makes it as that person; a key's is
+     * credited, in the feed and in the activity, to the key's maker.
+     *
+     * @param {Taktoria.CreateMemeRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.createMeme({
+     *         templateId: "templateId",
+     *         captions: ["captions", "captions"]
+     *     })
+     */
+    createMeme(request: Taktoria.CreateMemeRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.Meme>;
+    private __createMeme;
+    /**
+     * @param {string} memeId
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.getMeme("memeId")
+     */
+    getMeme(memeId: string, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.Meme>;
+    private __getMeme;
+    /**
+     * Upvote a meme as the signed-in person. Already upvoted, nothing
+     * changes: it answers the same however often it is sent. A vote is a
+     * person's, so an API key, which acts for the workspace, is refused
+     * with `403 forbidden`. Answers with the meme, its new `score` and
+     * `hasVoted: true`.
+     *
+     * @param {string} memeId
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.voteMeme("mem_7f3a")
+     */
+    voteMeme(memeId: string, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.Meme>;
+    private __voteMeme;
+    /**
+     * Take the signed-in person's upvote back. Not upvoted, nothing
+     * changes. Refused for an API key (`403 forbidden`), as voting is.
+     * Answers with the meme, its new `score` and `hasVoted: false`.
+     *
+     * @param {string} memeId
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.unvoteMeme("memeId")
+     */
+    unvoteMeme(memeId: string, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.Meme>;
+    private __unvoteMeme;
+    /**
+     * The meme as a PNG, drawn exactly as the app's download draws it, at
+     * its background's proportions. For a key or a signed-in session alike
+     * (the app's own image address answers only a browser signed in to the
+     * app). Drawing is expensive, so it counts against the `meme-render`
+     * budget as well (see "Rate limits"). `502 upstream_error` when the
+     * background could not be fetched to draw it.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.UpstreamError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     */
+    getMemeImage(memeId: string, request?: Taktoria.GetMemeImageRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<core.BinaryResponse>;
+    private __getMemeImage;
+    /**
+     * What `POST /memes` would make, drawn as a PNG and not saved: the
+     * same body, the same checks (`422` for an archived template or no
+     * words, `404` for a template not in the workspace) and the same
+     * fitting, so it can be shown to somebody before everybody sees it.
+     * Nothing is written, so it needs only `memes:read`. It counts against
+     * the `meme-render` budget as `GET /memes/{memeId}/image` does, and as
+     * a write against the caller's own limits, being a `POST`.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.UpstreamError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     */
+    previewMeme(request: Taktoria.PreviewMemeRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<core.BinaryResponse>;
+    private __previewMeme;
+    /**
+     * There is no update beside it on purpose. A meme is a thing somebody
+     * said and the votes under it are the room agreeing: editing the
+     * captions under a score would make those votes say something else.
+     *
+     * Its author may delete it, and so may an app admin of Memegen, as a
+     * moderator. In the app an app admin first turns **Moderate** on; this
+     * request is itself that deliberate act, so it always counts as
+     * moderating. A signed-in session therefore deletes the person's own
+     * or, for an app admin, anybody's; anybody else's is `403 forbidden`,
+     * and a Viewer of Memegen deletes none, not even their own (`403
+     * viewer_only`). A key acts with an app admin's rights and deletes any
+     * meme in its workspace.
+     *
+     * @param {string} memeId
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.deleteMeme("memeId")
+     */
+    deleteMeme(memeId: string, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<void>;
+    private __deleteMeme;
+    /**
+     * The library a workspace curates, ordered by `sortOrder` then name.
+     * Archived templates and one-off backgrounds are listed for a key or
+     * the session of an app admin of Memegen; for anybody else's session they are left out
+     * (`archived=true` then returns an empty list, not `403`).
+     *
+     * @param {Taktoria.ListMemeTemplatesRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.UnauthorizedError}
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.listTemplates()
+     */
+    listTemplates(request?: Taktoria.ListMemeTemplatesRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplatePage>;
+    private __listTemplates;
+    /**
+     * Add a template to the library, by the app's library form's rules,
+     * whoever asks. A key acts with an app admin's rights; a signed-in
+     * session must be an app admin of Memegen's own (`403 admin_required`). The name is folded onto one
+     * line and kept to 120 characters; the address must be http or https;
+     * a picture already in the workspace is promoted into the library and
+     * renamed rather than added twice (`200`, with that template, rather
+     * than `201`); a new one is measured unless `width` and `height` are
+     * sent, and goes to the end of the picker unless `sortOrder` says
+     * otherwise. A key's template is credited to the key's maker.
+     *
+     * @param {Taktoria.CreateMemeTemplateRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.ConflictError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.createTemplate({
+     *         name: "name",
+     *         imageUrl: "imageUrl"
+     *     })
+     */
+    createTemplate(request: Taktoria.CreateMemeTemplateRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __createTemplate;
+    /**
+     * Add a background by sending the picture itself, as multipart/form-data.
+     *
+     * `createTemplate` takes an address, which assumes the caller already has
+     * somewhere to serve the file from. A script pulling pictures out of a
+     * shared drive does not. The image's dimensions are read from the file,
+     * so they do not need to be supplied.
+     *
+     * It joins the library unless sent `curate=false`, so by default it is
+     * a key's, which acts with an app admin's rights, or the session of an
+     * app admin of Memegen; anybody else's session is `403 admin_required`. With
+     * `curate=false` it is a background for one meme, which anybody but a
+     * Viewer of Memegen (`403 viewer_only`) may upload, as in the app and
+     * through MCP, and stays out of the picker.
+     * Each upload is a new template; its slug comes from its name,
+     * numbered (`-2`, `-3`…) if it clashes.
+     *
+     * @param {Taktoria.UploadMemeTemplateRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     */
+    uploadTemplate(request: Taktoria.UploadMemeTemplateRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __uploadTemplate;
+    /**
+     * Use a picture on the web as a background, by its address, as the
+     * composer's box does: named after the file, with two captions
+     * (`TOP_BOTTOM`). Left out of the library unless `curate` is `true`
+     * (a key's, or the session of an app admin of Memegen), so anybody but
+     * a Viewer of Memegen may add one for the meme they are making. A new one is `201`. The same address again is
+     * the template already there, `200`, promoted into the library if
+     * `curate` asks; if an app admin archived it, a key or an app admin's session
+     * gets it back in the picker, and anybody else is refused with
+     * `403 admin_required` and it stays archived. A key's is credited to
+     * the key's maker.
+     *
+     * @param {Taktoria.MemeTemplateFromUrlRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.addTemplateFromUrl({
+     *         url: "https://acme.com/whiteboard.png"
+     *     })
+     */
+    addTemplateFromUrl(request: Taktoria.MemeTemplateFromUrlRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __addTemplateFromUrl;
+    /**
+     * Search memegen.link, the public catalogue of well-known meme formats,
+     * for a background, as the composer's search box does. Nothing is
+     * added to the workspace: send a result to `POST
+     * /meme-templates/import` to use it. Anybody with a seat may search.
+     * memegen.link is somebody else's free service, so this counts against
+     * the `memegen-link-search` budget as well (see "Rate limits"). Its
+     * catalogue is kept for a day and searched here, so a search seldom
+     * reaches memegen.link; when the copy is due and memegen.link is down,
+     * the last copy is searched. Only with no copy at all is it
+     * `502 upstream_error`, when memegen.link times out, refuses or answers
+     * with something unreadable.
+     *
+     * @param {Taktoria.SearchMemeFormatsRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.UpstreamError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.searchMemeFormats({
+     *         q: "success"
+     *     })
+     */
+    searchMemeFormats(request: Taktoria.SearchMemeFormatsRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeFormatList>;
+    private __searchMemeFormats;
+    /**
+     * Bring a result from `GET /meme-formats` into the workspace as a
+     * template, with its credit, as the composer does. The result is
+     * checked again as memegen.link's own answer was (an https picture, 1
+     * to 3 captions), so one altered on the way back that no longer makes
+     * a usable background is `422`. Left out of the library unless
+     * `curate` is `true` (a key's, or the session of an app admin of
+     * Memegen). A new one is `201`; the same format again is the template
+     * already there, `200`, and one an app admin archived comes back only
+     * for a key or an app admin's session (`403 admin_required` for anybody else's).
+     *
+     * @param {Taktoria.ImportMemeFormatRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.importMemeFormat({
+     *         id: "id",
+     *         title: "title",
+     *         url: "url",
+     *         lines: 1
+     *     })
+     */
+    importMemeFormat(request: Taktoria.ImportMemeFormatRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __importMemeFormat;
+    /**
+     * Arrange the picker in one call, as the library page's drag does: the
+     * ids first to last. Ids not in the library are ignored, and library
+     * templates left out keep their order after those listed, so a stale
+     * list cannot drop one. A key, or the session of an app admin of
+     * Memegen (`403 admin_required` for anybody else's). Answers with the whole library
+     * (curated, not archived) in its new order.
+     *
+     * @param {Taktoria.ReorderMemeTemplatesRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.SubscriptionRequiredError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.reorderTemplates({
+     *         ids: ["ids", "ids"]
+     *     })
+     */
+    reorderTemplates(request: Taktoria.ReorderMemeTemplatesRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplateList>;
+    private __reorderTemplates;
+    /**
+     * @param {string} templateId
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.getTemplate("templateId")
+     */
+    getTemplate(templateId: string, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __getTemplate;
+    /**
+     * A key, which acts with an app admin's rights, or the session of an
+     * app admin of Memegen (`403 admin_required` for anybody else's). Renaming and changing the
+     * slug are allowed, under the same rules as adding one: the name is
+     * folded onto one line and kept to 120 characters, and a slug another
+     * template holds is `409`. Archiving one (`archived: true`) stops new
+     * memes being made from it; `archived: false` restores an archived one
+     * to the picker.
+     *
+     * @param {string} templateId
+     * @param {Taktoria.UpdateMemeTemplateRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ValidationError}
+     * @throws {@link Taktoria.ConflictError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.updateTemplate("templateId", {})
+     */
+    updateTemplate(templateId: string, request: Taktoria.UpdateMemeTemplateRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<Taktoria.MemeTemplate>;
+    private __updateTemplate;
+    /**
+     * Archive it. Not a delete: memes already made from a template keep
+     * rendering, and removing the row would cascade them away. `PATCH`
+     * with `archived: false` puts it back. A key, or the session of an app
+     * admin of Memegen (`403 admin_required` for anybody else's).
+     *
+     * With `permanent=true` it is deleted for good instead, with its
+     * uploaded picture, as the library page's **Delete** does: only where
+     * there is nothing to lose, so a built-in (which would come straight
+     * back) or a template any meme was made from is `409 conflict`;
+     * archive those instead.
+     *
+     * @param {string} templateId
+     * @param {Taktoria.ArchiveMemeTemplateRequest} request
+     * @param {MemegenClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Taktoria.NotFoundError}
+     * @throws {@link Taktoria.ForbiddenError}
+     * @throws {@link Taktoria.ConflictError}
+     * @throws {@link Taktoria.TooManyRequestsError}
+     * @throws {@link errors.TaktoriaError}
+     * @throws {@link errors.TaktoriaTimeoutError}
+     *
+     * @example
+     *     await client.memegen.archiveTemplate("templateId")
+     */
+    archiveTemplate(templateId: string, request?: Taktoria.ArchiveMemeTemplateRequest, requestOptions?: MemegenClient.RequestOptions): core.HttpResponsePromise<void>;
+    private __archiveTemplate;
+}