@sinatra-dev/sdk 0.0.0-stage → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,929 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * 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 = ClientOptions> 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 {
+    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<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<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'>);
+
+/**
+ * A message to send on a task.
+ */
+type CreateMessageRequest = {
+    /**
+     * The message, up to 100,000 characters after trimming.
+     */
+    text: string;
+};
+/**
+ * The message that was sent.
+ */
+type CreateMessageResponse = {
+    /**
+     * The message's id: the `Idempotency-Key` you sent, or a generated id.
+     */
+    messageId: string;
+};
+/**
+ * A task to start.
+ */
+type CreateTaskRequest = {
+    /**
+     * What to do, as you'd ask a teammate. Up to 100,000 characters, after trimming.
+     */
+    prompt: string;
+    /**
+     * The task's title, up to 200 characters. Defaults to the prompt's first line, cut to 80 characters.
+     */
+    title?: string | null;
+    /**
+     * `owner/name` of a repository connected to the workspace. Omit it to let the agent choose.
+     */
+    repo?: string | null;
+};
+/**
+ * The task that started, and the id of your first message.
+ */
+type CreateTaskResponse = {
+    task: Task;
+    /**
+     * The id of your first message: the `Idempotency-Key` you sent, or a generated id.
+     */
+    messageId: string;
+};
+/**
+ * A GitHub issue to delegate, by its repository and number.
+ */
+type DelegateGithubTicket = {
+    /**
+     * `github` to delegate a GitHub issue.
+     */
+    source: 'github';
+    /**
+     * `owner/name` of a repository enabled in the workspace.
+     */
+    repo: string;
+    /**
+     * The issue's number in that repository.
+     */
+    number: number;
+};
+/**
+ * A Linear issue to delegate, by its identifier or id.
+ */
+type DelegateLinearTicket = {
+    /**
+     * `linear` to delegate a Linear issue.
+     */
+    source: 'linear';
+    /**
+     * The issue's identifier, such as `ENG-123`, or its id.
+     */
+    id: string;
+};
+/**
+ * An issue to delegate: a Linear issue by `id`, or a GitHub issue by `repo` and `number`.
+ */
+type DelegateTicketRequest = ({
+    source: 'linear';
+} & DelegateLinearTicket) | ({
+    source: 'github';
+} & DelegateGithubTicket);
+/**
+ * The issue was delegated.
+ */
+type DelegateTicketResponse = {
+    /**
+     * Always `true`: the issue was handed to Sinatra.
+     */
+    ok: true;
+};
+/**
+ * The body of every error response.
+ */
+type Error$1 = {
+    /**
+     * A machine-readable code, such as `invalid_prompt`. Branch on this, not on `reason`. New codes can appear. Known codes: `assigned_to_other`, `bad_request`, `capacity_full`, `github_identity_required`, `github_not_connected`, `github_rate_limited`, `idempotency_conflict`, `internal_error`, `invalid_body`, `invalid_cursor`, `invalid_idempotency_key`, `invalid_limit`, `invalid_prompt`, `invalid_repo`, `invalid_status`, `invalid_title`, `invalid_token`, `issue_closed`, `issue_not_found`, `linear_app_user_missing`, `linear_identity_unlinked`, `linear_not_connected`, `linear_reconnect_required`, `not_an_api_task`, `not_an_issue`, `not_found`, `not_running`, `payment_required`, `repo_disabled`, `unavailable`.
+     */
+    error: string;
+    /**
+     * A sentence saying what went wrong and, where it helps, what to do. Written to show to a person.
+     */
+    reason?: string;
+    /**
+     * The request's id. Present on some errors, not all; the `x-request-id` response header always carries it. Share it with support.
+     */
+    requestId?: string;
+    /**
+     * Why a start was refused, on `payment_required` and `github_not_connected`. For `payment_required`: `own_credentials_required` or `subscription_inactive`. For `github_not_connected`: `missing` or `suspended`.
+     */
+    refusal?: string;
+    /**
+     * The settings section that fixes the refusal: your model credentials or billing, on `payment_required`; billing, when starting a task, on `capacity_full`.
+     */
+    billingUrl?: string;
+    /**
+     * The settings page that fixes the refusal, on `github_not_connected`.
+     */
+    settingsUrl?: string;
+    /**
+     * The workspace's plan, on `capacity_full` when starting a task.
+     */
+    plan?: string;
+    /**
+     * How many tasks the plan runs at a time, on `capacity_full` when starting a task.
+     */
+    running?: number;
+    /**
+     * How many tasks the plan queues, on `capacity_full` when starting a task.
+     */
+    queued?: number;
+    /**
+     * On `unavailable` after a start: the task that was made. Retry with the same key, or send a message on it.
+     */
+    taskId?: string;
+    /**
+     * On `unavailable`: the message that was saved but not sent yet. Retry with it as the `Idempotency-Key`.
+     */
+    messageId?: string;
+};
+/**
+ * The token's user and workspaces.
+ */
+type Me = {
+    /**
+     * The user the token acts as.
+     */
+    user: {
+        /**
+         * The user's id.
+         */
+        id: string;
+        /**
+         * The user's GitHub login. `null` for a user without GitHub.
+         */
+        githubLogin: string | null;
+        /**
+         * The user's name, if they have one.
+         */
+        name: string | null;
+        /**
+         * The user's email address: the one they sign in with by email, or their primary GitHub email.
+         */
+        email: string;
+    };
+    /**
+     * The workspaces the user belongs to, ordered by name.
+     */
+    workspaces: Array<Workspace>;
+};
+/**
+ * An entry in a task's conversation.
+ */
+type Message = {
+    /**
+     * The entry's id. Pass the last one you read as `after` to get only later entries.
+     */
+    id: string;
+    /**
+     * For a message a person sent: the id it was sent with, which is its idempotency key or a generated id. `null` on every other entry.
+     */
+    messageId: string | null;
+    /**
+     * Who wrote it: `user` for a person, `agent` for the agent, `platform` for Sinatra itself. New roles can appear.
+     */
+    role: string;
+    /**
+     * What it is: `message` (a person's message), `response` (the agent's answer for a turn, or a notice from Sinatra such as a stop or files the agent produced), `clarify` (a question the agent needs answered to continue) or `error` (a refusal or failure from Sinatra). New kinds can appear.
+     */
+    kind: string;
+    /**
+     * The text.
+     */
+    body: string;
+    /**
+     * When it was written.
+     */
+    createdAt: string;
+};
+/**
+ * A page of a task's conversation.
+ */
+type MessageList = {
+    /**
+     * The page's entries, oldest first.
+     */
+    messages: Array<Message>;
+    /**
+     * When it isn't `null`, more entries follow: pass it as `after` to get them. `null` on the last page.
+     */
+    next: string | null;
+};
+/**
+ * The pull request a task opened.
+ */
+type PullRequest = {
+    /**
+     * The pull request's address on GitHub.
+     */
+    url: string;
+    /**
+     * `true` once the pull request is merged.
+     */
+    merged: boolean;
+};
+/**
+ * The stop was accepted.
+ */
+type StopTaskResponse = {
+    /**
+     * Always `true`: the task was told to stop.
+     */
+    accepted: true;
+};
+/**
+ * A task: one piece of work Sinatra does, from any source.
+ */
+type Task = {
+    /**
+     * The task's id. Use it as `taskId` in the task endpoints.
+     */
+    id: string;
+    /**
+     * Where the task is in its life, such as `pending`, `implementing`, `replied`, `pr_open` or `completed`. New statuses can appear, so don't treat the list as closed. See [Raw statuses](https://docs.sinatra.dev/docs/getting-started/how-it-works#raw-statuses) for each one.
+     */
+    status: string;
+    /**
+     * Where the task started: `api` for the CLI, MCP, this API or the dashboard, `linear` or `github_issue` for an issue, `slack` or `telegram` for a chat. Other sources can appear, so treat an unknown value as a task started elsewhere.
+     */
+    source: string;
+    /**
+     * The task's title. `null` for a task whose issue has no title.
+     */
+    title: string | null;
+    /**
+     * `owner/name` of the task's repository. `null` until a repository is chosen.
+     */
+    repo: string | null;
+    /**
+     * The task's pull request. `null` until one opens.
+     */
+    pullRequest: PullRequest | null;
+    /**
+     * `true` while a turn waits because the workspace is already running as many tasks at a time as its plan allows. The dashboard shows this as Queued.
+     */
+    queued: boolean;
+    /**
+     * When the task was created.
+     */
+    createdAt: string;
+    /**
+     * When the task last did something. `null` if it hasn't yet.
+     */
+    lastActivityAt: string | null;
+    /**
+     * The task's page in the Sinatra dashboard, where anyone in the workspace can follow it. On a task started from the CLI, MCP, API or dashboard they can reply there too.
+     */
+    url: string | null;
+};
+/**
+ * A page of tasks.
+ */
+type TaskList = {
+    /**
+     * The page's tasks, most recently active first.
+     */
+    tasks: Array<Task>;
+    /**
+     * Pass it back as `cursor` to get the next page. Treat it as opaque. `null` on the last page.
+     */
+    nextCursor: string | null;
+};
+/**
+ * An open issue you could delegate to Sinatra.
+ */
+type Ticket = {
+    /**
+     * The issue's id on Sinatra's side. For GitHub it looks like `github:owner/name#42`.
+     */
+    id: string;
+    /**
+     * Where the issue lives: `linear` or `github`. New sources can appear.
+     */
+    source: string;
+    /**
+     * What to delegate it by. A Linear identifier such as `ENG-123` (send it as `id`), or a GitHub `owner/name#42` (send `owner/name` as `repo` and `42` as `number`).
+     */
+    identifier: string;
+    /**
+     * The issue's title.
+     */
+    title: string;
+    /**
+     * `true` if the issue is assigned to you or you wrote it.
+     */
+    yours: boolean;
+    /**
+     * A GitHub issue's state, such as `open`. `null` for a Linear issue.
+     */
+    state: string | null;
+    /**
+     * The Linear team's name, or the GitHub repository's name.
+     */
+    context: string | null;
+    /**
+     * The issue's address on its tracker.
+     */
+    url: string;
+    /**
+     * The id of the workspace that was searched.
+     */
+    workspaceId: string;
+    /**
+     * The name the dashboard's ticket picker gives that workspace.
+     */
+    workspaceLabel: string;
+};
+/**
+ * The issues you could delegate, and how the workspace is connected to each tracker.
+ */
+type TicketSearchResult = {
+    /**
+     * The issues you could delegate. Linear issues come first, then GitHub's, each with yours before your team's unassigned ones.
+     */
+    tickets: Array<Ticket>;
+    /**
+     * The workspace's Linear connection, as it applies to you.
+     */
+    linear: {
+        /**
+         * Whether the workspace is connected to Linear.
+         */
+        connected: boolean;
+        /**
+         * Whether your Linear account is linked in this workspace. Linear issues are listed only when it is.
+         */
+        identityLinked: boolean;
+        /**
+         * Whether your Linear identity is tied to your Sinatra user.
+         */
+        identityBound: boolean;
+    };
+    /**
+     * The workspace's GitHub connection.
+     */
+    github: {
+        /**
+         * Whether the workspace is connected to GitHub.
+         */
+        connected: boolean;
+        /**
+         * The repository the GitHub search covered, when the `repo` query matched an enabled one and had open issues. Otherwise `null`.
+         */
+        repo: string | null;
+    };
+};
+/**
+ * A workspace you belong to.
+ */
+type Workspace = {
+    /**
+     * The workspace's id. Use it as `workspaceId` in the workspace endpoints.
+     */
+    id: string;
+    /**
+     * The workspace's name.
+     */
+    name: string;
+    /**
+     * Your role in it: `owner`, `admin` or `member`. New roles can appear.
+     */
+    role: string;
+};
+type TasksListData = {
+    body?: never;
+    path: {
+        /**
+         * The workspace's id, from `GET /v1/me`.
+         */
+        workspaceId: string;
+    };
+    query?: {
+        /**
+         * Only tasks in this status, such as `implementing` or `pr_open`. A name that isn't a task status is `invalid_status`.
+         */
+        status?: string;
+        /**
+         * How many tasks to return, 1 to 100.
+         */
+        limit?: number;
+        /**
+         * `nextCursor` from the previous page. Treat it as opaque.
+         */
+        cursor?: string;
+    };
+    url: '/v1/workspaces/{workspaceId}/tasks';
+};
+type MessagesListData = {
+    body?: never;
+    path: {
+        /**
+         * The workspace's id, from `GET /v1/me`.
+         */
+        workspaceId: string;
+        /**
+         * The task's id.
+         */
+        taskId: string;
+    };
+    query?: {
+        /**
+         * The `id` of the last entry you've read. Returns only later entries. An id that isn't an entry of this task is `invalid_cursor`.
+         */
+        after?: string;
+        /**
+         * How many entries to return, 1 to 200.
+         */
+        limit?: number;
+    };
+    url: '/v1/workspaces/{workspaceId}/tasks/{taskId}/messages';
+};
+type TicketsSearchData = {
+    body?: never;
+    path: {
+        /**
+         * The workspace's id, from `GET /v1/me`.
+         */
+        workspaceId: string;
+    };
+    query?: {
+        /**
+         * Text to match: GitHub search terms, and a substring of a Linear issue's title. Up to 200 characters.
+         */
+        q?: string;
+        /**
+         * `owner/name` of an enabled repository to search first on GitHub. A repository that isn't enabled is ignored.
+         */
+        repo?: string;
+    };
+    url: '/v1/workspaces/{workspaceId}/tickets';
+};
+
+interface CallOptions {
+    /** Cancels the call, including a retry it is waiting to make. */
+    signal?: AbortSignal;
+    /** Milliseconds each attempt may take before it is aborted with a `TimeoutError`. `0` for none; at most 2^31-1 (about 24.8 days). */
+    timeout?: number;
+}
+
+/**
+ * The one error the client throws for an HTTP error response.
+ *
+ * `code` is the API's machine-readable `error` code, such as `capacity_full`.
+ * New codes can appear at any time, so treat it as an open string. Branch on
+ * `code`, not on `reason` or `message`.
+ *
+ * Network failures (DNS, refused connections) are not wrapped: they reject
+ * with the error `fetch` threw.
+ */
+declare class SinatraError extends Error {
+    readonly name = "SinatraError";
+    /** The HTTP status, such as `409`. */
+    readonly status: number;
+    /**
+     * The API's `error` code, such as `not_running`. `http_error` when the
+     * response had no code, for example an HTML page from a proxy.
+     */
+    readonly code: string;
+    /** A sentence saying what went wrong, written to show to a person. */
+    readonly reason: string | undefined;
+    /** The request's id, from the body or the `x-request-id` header. Share it with support. */
+    readonly requestId: string | undefined;
+    /** The response body: the parsed JSON object, or the text when it wasn't JSON. */
+    readonly body: unknown;
+    /** The response headers. */
+    readonly headers: Headers;
+    constructor(status: number, body: unknown, headers: Headers);
+}
+
+declare const DEFAULT_BASE_URL = "https://api.sinatra.dev";
+/** How long one attempt may take, by default. */
+declare const DEFAULT_TIMEOUT_MS = 60000;
+
+interface SinatraOptions {
+    /** An API token (`sntr_...`). Defaults to the `SINATRA_TOKEN` environment variable. */
+    token?: string;
+    /** Defaults to `https://api.sinatra.dev`. */
+    baseUrl?: string;
+    /** A `fetch` to use instead of the global one. */
+    fetch?: typeof fetch;
+    /**
+     * Milliseconds each attempt may take before it is aborted with a
+     * `TimeoutError`. Defaults to 60 seconds; `0` for none. A call can
+     * override it, and pass a `signal`, in its last argument.
+     */
+    timeout?: number;
+}
+interface IdempotencyOptions extends CallOptions {
+    /**
+     * 1 to 128 printable ASCII characters, with no spaces. When you leave it
+     * out, the client makes a random UUID. Either way, every retry of the call
+     * sends the same key, so a retried start never starts a second task.
+     */
+    idempotencyKey?: string;
+}
+type ListTasksQuery = NonNullable<TasksListData["query"]>;
+type ListMessagesQuery = NonNullable<MessagesListData["query"]>;
+type SearchTicketsQuery = NonNullable<TicketsSearchData["query"]>;
+/**
+ * A client for the Sinatra API. Its namespaces mirror the API's operations:
+ * `me.get` is `GET /v1/me`, `tasks.create` is `POST /v1/workspaces/{workspaceId}/tasks`.
+ *
+ * Requests that are safe to repeat (GETs, the token DELETE, and starts and
+ * messages, which always carry an `Idempotency-Key`) are retried up to 3 times
+ * on `429` and `503`. `tasks.stop` is retried on `503` only. Errors throw
+ * {@link SinatraError}.
+ *
+ * Reference: https://docs.sinatra.dev/docs/api-reference
+ */
+declare class Sinatra {
+    readonly me: MeApi;
+    readonly tasks: TasksApi;
+    readonly messages: MessagesApi;
+    readonly tickets: TicketsApi;
+    constructor(options?: SinatraOptions);
+}
+/** What every namespace shares: the generated client and the default timeout. */
+interface Context {
+    client: Client;
+    timeout: number;
+}
+declare class MeApi {
+    private readonly ctx;
+    /** @internal */
+    constructor(ctx: Context);
+    /** `me.get`: the user the token acts as, and their workspaces. */
+    get(options?: CallOptions): Promise<Me>;
+    /** `me.revokeToken`: revokes the token this client sends. Later requests get `401`. */
+    revokeToken(options?: CallOptions): Promise<void>;
+}
+declare class TasksApi {
+    private readonly ctx;
+    /** @internal */
+    constructor(ctx: Context);
+    /** `tasks.list`: one page of the workspace's tasks, most recently active first. */
+    list(workspaceId: string, query?: ListTasksQuery, options?: CallOptions): Promise<TaskList>;
+    /** Every task from `query.cursor` on (or from the start), following `nextCursor` page by page. */
+    listAll(workspaceId: string, query?: ListTasksQuery, options?: CallOptions): AsyncGenerator<Task, void, undefined>;
+    /** `tasks.get`: one task, wherever it started. */
+    get(workspaceId: string, taskId: string, options?: CallOptions): Promise<Task>;
+    /**
+     * `tasks.create`: starts a task. Answers once the task is made, not when it's done:
+     * poll `tasks.get` and `messages.list` to follow it.
+     */
+    create(workspaceId: string, body: CreateTaskRequest, options?: IdempotencyOptions): Promise<CreateTaskResponse>;
+    /** `tasks.stop`: stops the task's running turn. A task that isn't running is `409 not_running`. */
+    stop(workspaceId: string, taskId: string, options?: CallOptions): Promise<StopTaskResponse>;
+}
+declare class MessagesApi {
+    private readonly ctx;
+    /** @internal */
+    constructor(ctx: Context);
+    /** `messages.create`: sends a follow-up on a task started from the API, CLI, MCP or dashboard. */
+    create(workspaceId: string, taskId: string, body: CreateMessageRequest, options?: IdempotencyOptions): Promise<CreateMessageResponse>;
+    /**
+     * `messages.list`: one page of the task's conversation, oldest first. To wait
+     * for a reply, poll with `after` set to the `id` of the last entry you read.
+     */
+    list(workspaceId: string, taskId: string, query?: ListMessagesQuery, options?: CallOptions): Promise<MessageList>;
+    /** Every entry after `query.after` (or from the start), following `next` page by page. */
+    listAll(workspaceId: string, taskId: string, query?: ListMessagesQuery, options?: CallOptions): AsyncGenerator<Message, void, undefined>;
+}
+declare class TicketsApi {
+    private readonly ctx;
+    /** @internal */
+    constructor(ctx: Context);
+    /** `tickets.search`: open Linear and GitHub issues you could delegate. */
+    search(workspaceId: string, query?: SearchTicketsQuery, options?: CallOptions): Promise<TicketSearchResult>;
+    /**
+     * `tickets.delegate`: hands Sinatra an existing issue as you. Not retried:
+     * the operation takes no `Idempotency-Key`.
+     */
+    delegate(workspaceId: string, body: DelegateTicketRequest, options?: CallOptions): Promise<DelegateTicketResponse>;
+}
+
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, MeApi, MessagesApi, Sinatra, SinatraError, TasksApi, TicketsApi };
+export type { CallOptions, CreateMessageRequest, CreateMessageResponse, CreateTaskRequest, CreateTaskResponse, DelegateGithubTicket, DelegateLinearTicket, DelegateTicketRequest, DelegateTicketResponse, Error$1 as ErrorBody, IdempotencyOptions, ListMessagesQuery, ListTasksQuery, Me, Message, MessageList, PullRequest, SearchTicketsQuery, SinatraOptions, StopTaskResponse, Task, TaskList, Ticket, TicketSearchResult, Workspace };