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

package/contract/email-validation/models.d.ts

@@ -0,0 +1,119 @@
+import * as z from "zod";
+export declare const Reachability: z.ZodEnum<{
+    unknown: "unknown";
+    safe: "safe";
+    risky: "risky";
+    invalid: "invalid";
+}>;
+export type Reachability = z.infer<typeof Reachability>;
+export declare const CreateEmailValidation: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodEmail>;
+    suppressInvalid: z.ZodDefault<z.ZodBoolean>;
+    refresh: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateEmailValidation = z.infer<typeof CreateEmailValidation>;
+export declare const EmailValidationResult: z.ZodObject<{
+    address: z.ZodString;
+    reachability: z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>;
+    validSyntax: z.ZodBoolean;
+    domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+    deliverable: z.ZodNullable<z.ZodBoolean>;
+    disabled: z.ZodNullable<z.ZodBoolean>;
+    fullInbox: z.ZodNullable<z.ZodBoolean>;
+    catchAll: z.ZodNullable<z.ZodBoolean>;
+    disposable: z.ZodNullable<z.ZodBoolean>;
+    roleAccount: z.ZodNullable<z.ZodBoolean>;
+    suppressed: z.ZodBoolean;
+    cached: z.ZodBoolean;
+    checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+}, z.core.$strip>;
+export type EmailValidationResult = z.infer<typeof EmailValidationResult>;
+export declare const EmailValidation: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        reachability: z.ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>;
+        validSyntax: z.ZodBoolean;
+        domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+        deliverable: z.ZodNullable<z.ZodBoolean>;
+        disabled: z.ZodNullable<z.ZodBoolean>;
+        fullInbox: z.ZodNullable<z.ZodBoolean>;
+        catchAll: z.ZodNullable<z.ZodBoolean>;
+        disposable: z.ZodNullable<z.ZodBoolean>;
+        roleAccount: z.ZodNullable<z.ZodBoolean>;
+        suppressed: z.ZodBoolean;
+        cached: z.ZodBoolean;
+        checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EmailValidation = z.infer<typeof EmailValidation>;
+export declare const EmailValidationRecord: z.ZodObject<{
+    address: z.ZodString;
+    reachability: z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>;
+    validSyntax: z.ZodBoolean;
+    domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+    deliverable: z.ZodNullable<z.ZodBoolean>;
+    disabled: z.ZodNullable<z.ZodBoolean>;
+    fullInbox: z.ZodNullable<z.ZodBoolean>;
+    catchAll: z.ZodNullable<z.ZodBoolean>;
+    disposable: z.ZodNullable<z.ZodBoolean>;
+    roleAccount: z.ZodNullable<z.ZodBoolean>;
+    suppressed: z.ZodBoolean;
+    cached: z.ZodBoolean;
+    checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    id: z.ZodUUID;
+    createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+}, z.core.$strip>;
+export type EmailValidationRecord = z.infer<typeof EmailValidationRecord>;
+export declare const EmailValidationRecordPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        reachability: z.ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>;
+        validSyntax: z.ZodBoolean;
+        domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+        deliverable: z.ZodNullable<z.ZodBoolean>;
+        disabled: z.ZodNullable<z.ZodBoolean>;
+        fullInbox: z.ZodNullable<z.ZodBoolean>;
+        catchAll: z.ZodNullable<z.ZodBoolean>;
+        disposable: z.ZodNullable<z.ZodBoolean>;
+        roleAccount: z.ZodNullable<z.ZodBoolean>;
+        suppressed: z.ZodBoolean;
+        cached: z.ZodBoolean;
+        checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        id: z.ZodUUID;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EmailValidationRecordPage = z.infer<typeof EmailValidationRecordPage>;
+export declare const ListEmailValidationsQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    reachability: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>>;
+}, z.core.$strip>;
+export type ListEmailValidationsQuery = z.infer<typeof ListEmailValidationsQuery>;

package/contract/email-validation/routes.d.ts

@@ -0,0 +1,106 @@
+export declare const emailValidations: {
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        addresses: import("zod").ZodArray<import("zod").ZodEmail>;
+        suppressInvalid: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        refresh: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        results: import("zod").ZodArray<import("zod").ZodObject<{
+            address: import("zod").ZodString;
+            reachability: import("zod").ZodEnum<{
+                unknown: "unknown";
+                safe: "safe";
+                risky: "risky";
+                invalid: "invalid";
+            }>;
+            validSyntax: import("zod").ZodBoolean;
+            domainAcceptsMail: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            deliverable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disabled: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            fullInbox: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            catchAll: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disposable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            roleAccount: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            suppressed: import("zod").ZodBoolean;
+            cached: import("zod").ZodBoolean;
+            checkedAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+        }, import("zod/v4/core").$strip>>;
+    }, 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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly email_validation_disabled: "Email validation is unavailable.";
+        readonly email_validation_unavailable: "The validation service fails or does not answer in time; no address is suppressed.";
+        readonly email_validation_suspended: "The validation service refuses Workwae's requests for now; try again later.";
+        readonly plan_limit_validations: "The addresses to check again exceed what the plan allows today (UTC); nothing was checked.";
+        readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+        readonly validation_credits_exhausted: "The tenant has fewer email validation credits than the addresses to check again; data.balance and data.needed say how many; nothing was checked.";
+    }>>, Record<never, never>>;
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        address: import("zod").ZodOptional<import("zod").ZodString>;
+        reachability: import("zod").ZodOptional<import("zod").ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            address: import("zod").ZodString;
+            reachability: import("zod").ZodEnum<{
+                unknown: "unknown";
+                safe: "safe";
+                risky: "risky";
+                invalid: "invalid";
+            }>;
+            validSyntax: import("zod").ZodBoolean;
+            domainAcceptsMail: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            deliverable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disabled: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            fullInbox: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            catchAll: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disposable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            roleAccount: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            suppressed: import("zod").ZodBoolean;
+            cached: import("zod").ZodBoolean;
+            checkedAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+            id: import("zod").ZodUUID;
+            createdAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+        }, 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.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_cursor: "The cursor is not one this list issued.";
+    }>>, Record<never, never>>;
+};

package/contract/errors.d.ts

@@ -0,0 +1,116 @@
+import { type ErrorReason, type ReasonDataSchema, type ReasonStatus, type ReasonTable } from "./reasons.js";
+export type DeclaredError<R extends ErrorReason> = {
+    status: ReasonStatus<R>;
+    message: string;
+} & (ReasonDataSchema<R> extends undefined ? unknown : {
+    data: ReasonDataSchema<R>;
+});
+export type DeclaredErrors<C> = {
+    [R in keyof C & ErrorReason]: DeclaredError<R>;
+};
+export declare function errorMap(table: ReasonTable, conditions: Record<string, string | undefined>): Record<string, {
+    status: number;
+    message: string;
+    data?: unknown;
+}>;
+export declare function errors<const C extends {
+    [R in ErrorReason]?: string;
+}>(conditions: C): DeclaredErrors<C>;
+export declare const GLOBAL_ERRORS: 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.";
+}>;
+export declare const base: import("@orpc/contract").ContractBuilder<import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").MergedErrorMap<Record<never, never>, 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.";
+}>>, Record<never, never>>;
+export declare const SESSION_ONLY: DeclaredErrors<{
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
+}>;
+export declare const OWNER_ONLY: DeclaredErrors<{
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
+    readonly owner_required: "The caller does not own the organization.";
+}>;
+export declare const PLATFORM_ONLY: DeclaredErrors<{
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
+    readonly platform_admin_required: "The caller is not a platform administrator.";
+    readonly email_verification_required: "The platform administrator has not verified their email address yet.";
+}>;
+export declare const ACCOUNT_NOT_FOUND: DeclaredErrors<{
+    readonly account_not_found: "The account does not exist, or the caller is an account token for another account.";
+}>;
+export declare const MAIL_ACCOUNT: {
+    mail_disabled: {
+        status: 409;
+        message: string;
+    };
+    account_not_found: {
+        status: 404;
+        message: string;
+    };
+    plan_module_unavailable: {
+        status: 403;
+        message: string;
+    };
+};
+export declare function accountState(account?: string): DeclaredErrors<{
+    readonly account_paused: `${string} is paused.`;
+    readonly account_disabled: `${string} is disabled.`;
+    readonly account_reauth_required: `${string} must be reconnected: its stored grant or login no longer works.`;
+    readonly account_misconfigured: `${string}'s stored grant cannot be used until an administrator fixes what it relies on (the tenant's OAuth app or organization connection is refused, missing or unreadable).`;
+}>;
+export declare const PROVIDER_FAILURES: DeclaredErrors<{
+    readonly provider_throttled: "The provider asked us to slow down (with Retry-After when it named a wait).";
+    readonly provider_unavailable: "The provider could not be reached (with Retry-After when it named a wait).";
+}>;
+export declare function bodyStorage(field: string): DeclaredErrors<{
+    readonly storage_unavailable: `${string} is cache or full and no object store is configured.`;
+    readonly plan_limit_storage: `${string} is cache or full and the tenant's plan does not include body storage.`;
+}>;
+export declare function planModule(module: string): DeclaredErrors<{
+    readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
+}>;
+export declare const PLAN_REQUIRED_CONDITION = "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+export declare const PLAN_REQUIRED: DeclaredErrors<{
+    readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+}>;
+export declare function spendCapCondition(what: string): string;
+export declare const PLAN_LIMIT_ACCOUNTS: DeclaredErrors<{
+    readonly plan_limit_accounts: "The tenant already has as many accounts as its plan allows.";
+    readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+    readonly spend_cap_reached: string;
+}>;
+export declare const BILLING_PAST_DUE: DeclaredErrors<{
+    readonly billing_past_due: "The tenant's payment is past due beyond the grace period (sends already queued or scheduled still go out).";
+}>;
+export declare const INVALID_CURSOR: DeclaredErrors<{
+    readonly invalid_cursor: "The cursor is not one this list issued.";
+}>;