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

package/contract/suppressions/routes.d.ts

@@ -0,0 +1,365 @@
+import * as z from "zod";
+export declare const suppressions: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            count: z.ZodNumber;
+            counts: z.ZodObject<{
+                unsubscribe: z.ZodNumber;
+                bounce: z.ZodNumber;
+                api: z.ZodNumber;
+                reply: z.ZodNumber;
+                complaint: z.ZodNumber;
+                inactive: z.ZodNumber;
+                invalid: z.ZodNumber;
+            }, z.core.$strip>;
+            createdAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        }, z.core.$strip>>;
+    }, z.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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, Record<never, never>>;
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        count: z.ZodNumber;
+        counts: z.ZodObject<{
+            unsubscribe: z.ZodNumber;
+            bounce: z.ZodNumber;
+            api: z.ZodNumber;
+            reply: z.ZodNumber;
+            complaint: z.ZodNumber;
+            inactive: z.ZodNumber;
+            invalid: z.ZodNumber;
+        }, z.core.$strip>;
+        createdAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly suppression_list_exists: "A list with that id exists.";
+    }>>, Record<never, never>>;
+    update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        listId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        count: z.ZodNumber;
+        counts: z.ZodObject<{
+            unsubscribe: z.ZodNumber;
+            bounce: z.ZodNumber;
+            api: z.ZodNumber;
+            reply: z.ZodNumber;
+            complaint: z.ZodNumber;
+            inactive: z.ZodNumber;
+            invalid: z.ZodNumber;
+        }, z.core.$strip>;
+        createdAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly suppression_list_not_found: "The list does not exist (the global list has none to change).";
+    }>>, Record<never, never>>;
+    delete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        params: z.ZodObject<{
+            listId: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            withEntries: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [
+                z.ZodBoolean,
+                z.ZodEnum<{
+                    true: "true";
+                    false: "false";
+                }>
+            ]>, z.ZodTransform<boolean, boolean | "true" | "false">>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodVoid, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, {
+        suppression_list_not_empty: {
+            status: 409;
+            message: string;
+        };
+        suppression_list_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    entries: {
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            listId: z.ZodString;
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodString>;
+            address: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodEnum<{
+                api: "api";
+                invalid: "invalid";
+                bounce: "bounce";
+                unsubscribe: "unsubscribe";
+                reply: "reply";
+                complaint: "complaint";
+                inactive: "inactive";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                address: z.ZodString;
+                source: z.ZodEnum<{
+                    api: "api";
+                    invalid: "invalid";
+                    bounce: "bounce";
+                    unsubscribe: "unsubscribe";
+                    reply: "reply";
+                    complaint: "complaint";
+                    inactive: "inactive";
+                }>;
+                reason: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+            }, z.core.$strip>>;
+            nextCursor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<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.";
+        }>>, import("../errors.js").DeclaredErrors<{
+            readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+        }>>, import("../errors.js").DeclaredErrors<{
+            readonly invalid_cursor: "The cursor is not one this list issued.";
+        }>>, Record<never, never>>;
+        add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            listId: z.ZodString;
+            addresses: z.ZodArray<z.ZodEmail>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            added: z.ZodNumber;
+            alreadyListed: z.ZodNumber;
+        }, z.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.";
+        }>>, import("../errors.js").DeclaredErrors<{
+            readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+        }>>, Record<never, never>>;
+        remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            listId: z.ZodString;
+            address: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, import("@orpc/contract").MergedErrorMap<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.";
+        }>>, import("../errors.js").DeclaredErrors<{
+            readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+        }>>, import("../errors.js").DeclaredErrors<{
+            readonly suppression_entry_not_found: "The address is not on the list.";
+        }>>, Record<never, never>>;
+    };
+};
+export declare const suppressionReviews: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        listId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            listId: z.ZodString;
+            address: z.ZodString;
+            source: z.ZodEnum<{
+                reply: "reply";
+                complaint: "complaint";
+                inactive: "inactive";
+            }>;
+            accountId: z.ZodUUID;
+            messageId: z.ZodUUID;
+            probability: z.ZodNumber;
+            alternateContacts: z.ZodArray<z.ZodString>;
+            createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_cursor: "The cursor is not one this list issued.";
+    }>>, Record<never, never>>;
+    approve: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        reviewId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        added: z.ZodBoolean;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly suppression_review_not_found: "The review does not exist.";
+    }>>, Record<never, never>>;
+    dismiss: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        reviewId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodVoid, import("@orpc/contract").MergedErrorMap<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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly suppression_review_not_found: "The review does not exist.";
+    }>>, Record<never, never>>;
+};

package/contract/templates/models.d.ts

@@ -0,0 +1,155 @@
+import * as z from "zod";
+export declare const TemplateSource: z.ZodEnum<{
+    handlebars: "handlebars";
+    "react-email": "react-email";
+}>;
+export type TemplateSource = z.infer<typeof TemplateSource>;
+export declare const TemplateFormat: z.ZodEnum<{
+    markdown: "markdown";
+    html: "html";
+}>;
+export type TemplateFormat = z.infer<typeof TemplateFormat>;
+export declare const TemplateField: z.ZodEnum<{
+    text: "text";
+    subject: "subject";
+    html: "html";
+    previewText: "previewText";
+}>;
+export type TemplateField = z.infer<typeof TemplateField>;
+export declare const TemplateFields: z.ZodObject<{
+    subject: z.ZodNullable<z.ZodString>;
+    html: z.ZodNullable<z.ZodString>;
+    text: z.ZodNullable<z.ZodString>;
+    previewText: z.ZodNullable<z.ZodString>;
+    format: z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>;
+}, z.core.$strip>;
+export type TemplateFields = z.infer<typeof TemplateFields>;
+export declare const TemplateSummary: z.ZodObject<{
+    id: z.ZodUUID;
+    accountId: z.ZodNullable<z.ZodUUID>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        handlebars: "handlebars";
+        "react-email": "react-email";
+    }>;
+    externalRef: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+    updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+}, z.core.$strip>;
+export type TemplateSummary = z.infer<typeof TemplateSummary>;
+export declare const Template: z.ZodObject<{
+    id: z.ZodUUID;
+    accountId: z.ZodNullable<z.ZodUUID>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        handlebars: "handlebars";
+        "react-email": "react-email";
+    }>;
+    externalRef: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+    updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    subject: z.ZodNullable<z.ZodString>;
+    html: z.ZodNullable<z.ZodString>;
+    text: z.ZodNullable<z.ZodString>;
+    previewText: z.ZodNullable<z.ZodString>;
+    format: z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>;
+}, z.core.$strip>;
+export type Template = z.infer<typeof Template>;
+export declare const TemplateSummaryPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        accountId: z.ZodNullable<z.ZodUUID>;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            handlebars: "handlebars";
+            "react-email": "react-email";
+        }>;
+        externalRef: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TemplateSummaryPage = z.infer<typeof TemplateSummaryPage>;
+export declare const RenderParams: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type RenderParams = z.infer<typeof RenderParams>;
+export declare const RenderedTemplate: z.ZodObject<{
+    subject: z.ZodNullable<z.ZodString>;
+    html: z.ZodNullable<z.ZodString>;
+    text: z.ZodNullable<z.ZodString>;
+    previewText: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RenderedTemplate = z.infer<typeof RenderedTemplate>;
+export declare const TemplateIdInput: z.ZodObject<{
+    templateId: z.ZodUUID;
+}, z.core.$strip>;
+export type TemplateIdInput = z.infer<typeof TemplateIdInput>;
+export declare const ListTemplatesQuery: z.ZodObject<{
+    accountId: z.ZodOptional<z.ZodUUID>;
+    usableBy: z.ZodOptional<z.ZodUUID>;
+    name: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListTemplatesQuery = z.infer<typeof ListTemplatesQuery>;
+export declare const CreateTemplate: z.ZodObject<{
+    accountId: z.ZodOptional<z.ZodUUID>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    previewText: z.ZodOptional<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>>;
+    source: z.ZodDefault<z.ZodEnum<{
+        handlebars: "handlebars";
+        "react-email": "react-email";
+    }>>;
+    externalRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateTemplate = z.infer<typeof CreateTemplate>;
+export declare const UpdateTemplate: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    subject: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previewText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    format: z.ZodOptional<z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        handlebars: "handlebars";
+        "react-email": "react-email";
+    }>>;
+    externalRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type UpdateTemplate = z.infer<typeof UpdateTemplate>;
+export declare const RenderTemplateRequest: z.ZodObject<{
+    templateId: z.ZodOptional<z.ZodUUID>;
+    accountId: z.ZodOptional<z.ZodUUID>;
+    subject: z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    previewText: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        markdown: "markdown";
+        html: "html";
+    }>>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type RenderTemplateRequest = z.infer<typeof RenderTemplateRequest>;