@workwae/sdk 0.0.0-stage → 0.1.0-alpha.2

package/contract/ai/models.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod";
+export declare const AiDraftFormat: z.ZodEnum<{
+    text: "text";
+    markdown: "markdown";
+}>;
+export type AiDraftFormat = z.infer<typeof AiDraftFormat>;
+export declare const AiDraftContext: z.ZodObject<{
+    accountId: z.ZodOptional<z.ZodUUID>;
+    replyToMessageId: z.ZodOptional<z.ZodUUID>;
+    currentDraft: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AiDraftContext = z.infer<typeof AiDraftContext>;
+export declare const CreateAiDraft: z.ZodObject<{
+    instructions: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodOptional<z.ZodUUID>;
+        replyToMessageId: z.ZodOptional<z.ZodUUID>;
+        currentDraft: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    format: z.ZodEnum<{
+        text: "text";
+        markdown: "markdown";
+    }>;
+}, z.core.$strip>;
+export type CreateAiDraft = z.infer<typeof CreateAiDraft>;
+export declare const AiDraft: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export type AiDraft = z.infer<typeof AiDraft>;

package/contract/ai/routes.d.ts

@@ -0,0 +1,98 @@
+export declare const ai: {
+    draft: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        instructions: import("zod").ZodString;
+        context: import("zod").ZodOptional<import("zod").ZodObject<{
+            accountId: import("zod").ZodOptional<import("zod").ZodUUID>;
+            replyToMessageId: import("zod").ZodOptional<import("zod").ZodUUID>;
+            currentDraft: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        format: import("zod").ZodEnum<{
+            text: "text";
+            markdown: "markdown";
+        }>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        text: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
+        readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
+        readonly api_key_expired: "The API key is past its expiry (or the grace of the rotation that replaced it).";
+        readonly missing_scope: "The API key lacks the scope the operation needs.";
+        readonly role_forbidden: "The member's role does not allow the operation.";
+        readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
+        readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
+        readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
+        readonly overloaded: "The API is shedding load; retry after Retry-After.";
+        readonly payload_too_large: "The request body is larger than the API accepts.";
+        readonly internal_error: "An unexpected failure on our side.";
+        readonly invalid_idempotency_key: "POST only: the Idempotency-Key header is not 1 to 255 printable ASCII characters.";
+        readonly idempotency_key_reused: "POST only: the Idempotency-Key was used in the last 24 hours with another method, path or body.";
+        readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
+    }>>, {
+        unknown_account: import("../errors.js").DeclaredError<"unknown_account">;
+        mail_disabled: {
+            status: 409;
+            message: string;
+        };
+        provider_not_found: {
+            status: 404;
+            message: string;
+        };
+        provider_forbidden: {
+            status: 403;
+            message: string;
+        };
+        ai_disabled: {
+            status: 400;
+            message: string;
+        };
+        ai_unavailable: {
+            status: 502;
+            message: string;
+        };
+        ai_suspended: {
+            status: 502;
+            message: string;
+        };
+        ai_refused: {
+            status: 400;
+            message: string;
+        };
+        unknown_message: {
+            status: 422;
+            message: string;
+        };
+        provider_unavailable: {
+            status: 502;
+            message: string;
+        };
+        provider_throttled: {
+            status: 429;
+            message: string;
+        };
+        account_paused: {
+            status: 409;
+            message: string;
+        };
+        account_disabled: {
+            status: 409;
+            message: string;
+        };
+        account_reauth_required: {
+            status: 409;
+            message: string;
+        };
+        account_misconfigured: {
+            status: 409;
+            message: string;
+        };
+        plan_required: import("../errors.js").DeclaredError<"plan_required">;
+        spend_cap_reached: import("../errors.js").DeclaredError<"spend_cap_reached">;
+        plan_limit_ai: import("../errors.js").DeclaredError<"plan_limit_ai">;
+        plan_module_unavailable: {
+            status: 403;
+            message: string;
+        };
+    }>, Record<never, never>>;
+};

package/contract/audit-log/models.d.ts

@@ -0,0 +1,121 @@
+import * as z from "zod";
+export declare const AuditActorType: z.ZodEnum<{
+    user: "user";
+    apiKey: "apiKey";
+    accountToken: "accountToken";
+    connectSession: "connectSession";
+    scimCredential: "scimCredential";
+}>;
+export type AuditActorType = z.infer<typeof AuditActorType>;
+export declare const AuditActor: z.ZodObject<{
+    type: z.ZodEnum<{
+        user: "user";
+        apiKey: "apiKey";
+        accountToken: "accountToken";
+        connectSession: "connectSession";
+        scimCredential: "scimCredential";
+    }>;
+    id: z.ZodUUID;
+    label: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AuditActor = z.infer<typeof AuditActor>;
+export declare const AuditSurface: z.ZodEnum<{
+    auth: "auth";
+    v1: "v1";
+    rpc: "rpc";
+    mcp: "mcp";
+}>;
+export type AuditSurface = z.infer<typeof AuditSurface>;
+export declare const AuditOutcome: z.ZodEnum<{
+    success: "success";
+    failure: "failure";
+}>;
+export type AuditOutcome = z.infer<typeof AuditOutcome>;
+export declare const AuditEntry: z.ZodObject<{
+    id: z.ZodUUID;
+    createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+    actor: z.ZodObject<{
+        type: z.ZodEnum<{
+            user: "user";
+            apiKey: "apiKey";
+            accountToken: "accountToken";
+            connectSession: "connectSession";
+            scimCredential: "scimCredential";
+        }>;
+        id: z.ZodUUID;
+        label: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    action: z.ZodString;
+    surface: z.ZodEnum<{
+        auth: "auth";
+        v1: "v1";
+        rpc: "rpc";
+        mcp: "mcp";
+    }>;
+    targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+        z.ZodString,
+        z.ZodArray<z.ZodString>
+    ]>>;
+    ip: z.ZodNullable<z.ZodString>;
+    userAgent: z.ZodNullable<z.ZodString>;
+    status: z.ZodNumber;
+    errorReason: z.ZodNullable<z.ZodString>;
+    requestId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AuditEntry = z.infer<typeof AuditEntry>;
+export declare const AuditEntryPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        actor: z.ZodObject<{
+            type: z.ZodEnum<{
+                user: "user";
+                apiKey: "apiKey";
+                accountToken: "accountToken";
+                connectSession: "connectSession";
+                scimCredential: "scimCredential";
+            }>;
+            id: z.ZodUUID;
+            label: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        action: z.ZodString;
+        surface: z.ZodEnum<{
+            auth: "auth";
+            v1: "v1";
+            rpc: "rpc";
+            mcp: "mcp";
+        }>;
+        targets: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+            z.ZodString,
+            z.ZodArray<z.ZodString>
+        ]>>;
+        ip: z.ZodNullable<z.ZodString>;
+        userAgent: z.ZodNullable<z.ZodString>;
+        status: z.ZodNumber;
+        errorReason: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AuditEntryPage = z.infer<typeof AuditEntryPage>;
+export declare const ListAuditLogQuery: z.ZodObject<{
+    actorType: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        apiKey: "apiKey";
+        accountToken: "accountToken";
+        connectSession: "connectSession";
+        scimCredential: "scimCredential";
+    }>>;
+    actorId: z.ZodOptional<z.ZodUUID>;
+    action: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodUUID>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        failure: "failure";
+    }>>;
+    from: z.ZodOptional<z.ZodPreprocess<z.ZodDate, string | Date>>;
+    to: z.ZodOptional<z.ZodPreprocess<z.ZodDate, string | Date>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListAuditLogQuery = z.infer<typeof ListAuditLogQuery>;

package/contract/audit-log/routes.d.ts

@@ -0,0 +1,81 @@
+export declare const auditLog: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        actorType: import("zod").ZodOptional<import("zod").ZodEnum<{
+            user: "user";
+            apiKey: "apiKey";
+            accountToken: "accountToken";
+            connectSession: "connectSession";
+            scimCredential: "scimCredential";
+        }>>;
+        actorId: import("zod").ZodOptional<import("zod").ZodUUID>;
+        action: import("zod").ZodOptional<import("zod").ZodString>;
+        accountId: import("zod").ZodOptional<import("zod").ZodUUID>;
+        outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+            success: "success";
+            failure: "failure";
+        }>>;
+        from: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDate, string | Date>>;
+        to: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDate, string | Date>>;
+        limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            createdAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+            actor: import("zod").ZodObject<{
+                type: import("zod").ZodEnum<{
+                    user: "user";
+                    apiKey: "apiKey";
+                    accountToken: "accountToken";
+                    connectSession: "connectSession";
+                    scimCredential: "scimCredential";
+                }>;
+                id: import("zod").ZodUUID;
+                label: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            action: import("zod").ZodString;
+            surface: import("zod").ZodEnum<{
+                auth: "auth";
+                v1: "v1";
+                rpc: "rpc";
+                mcp: "mcp";
+            }>;
+            targets: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [
+                import("zod").ZodString,
+                import("zod").ZodArray<import("zod").ZodString>
+            ]>>;
+            ip: import("zod").ZodNullable<import("zod").ZodString>;
+            userAgent: import("zod").ZodNullable<import("zod").ZodString>;
+            status: import("zod").ZodNumber;
+            errorReason: import("zod").ZodNullable<import("zod").ZodString>;
+            requestId: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
+        readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
+        readonly api_key_expired: "The API key is past its expiry (or the grace of the rotation that replaced it).";
+        readonly missing_scope: "The API key lacks the scope the operation needs.";
+        readonly role_forbidden: "The member's role does not allow the operation.";
+        readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
+        readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
+        readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
+        readonly overloaded: "The API is shedding load; retry after Retry-After.";
+        readonly payload_too_large: "The request body is larger than the API accepts.";
+        readonly internal_error: "An unexpected failure on our side.";
+        readonly invalid_idempotency_key: "POST only: the Idempotency-Key header is not 1 to 255 printable ASCII characters.";
+        readonly idempotency_key_reused: "POST only: the Idempotency-Key was used in the last 24 hours with another method, path or body.";
+        readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
+    }>>, {
+        invalid_range: {
+            status: 400;
+            message: string;
+        };
+        invalid_cursor: {
+            status: 400;
+            message: string;
+        };
+    }>, Record<never, never>>;
+};