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

package/contract/org-connections/routes.d.ts

@@ -0,0 +1,1107 @@
+import * as z from "zod";
+export declare const orgConnections: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            kind: z.ZodEnum<{
+                google_delegation: "google_delegation";
+                microsoft_app: "microsoft_app";
+            }>;
+            name: z.ZodString;
+            clientId: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                unverified: "unverified";
+                failing: "failing";
+                pending_consent: "pending_consent";
+            }>;
+            statusDetail: z.ZodNullable<z.ZodString>;
+            checkedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+            google: z.ZodNullable<z.ZodObject<{
+                domain: z.ZodString;
+                serviceAccountEmail: z.ZodString;
+                directoryAdmin: z.ZodNullable<z.ZodString>;
+                scopes: z.ZodArray<z.ZodString>;
+                groupsEnabled: z.ZodBoolean;
+            }, z.core.$strip>>;
+            microsoft: z.ZodNullable<z.ZodObject<{
+                cloud: z.ZodEnum<{
+                    global: "global";
+                    "gcc-high": "gcc-high";
+                    dod: "dod";
+                    china: "china";
+                }>;
+                credentialType: z.ZodEnum<{
+                    platform: "platform";
+                    client_secret: "client_secret";
+                    certificate: "certificate";
+                }>;
+                directoryId: z.ZodNullable<z.ZodString>;
+                permissions: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    isRequired: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            accounts: z.ZodNumber;
+            createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+            updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, 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.";
+    }>>, Record<never, never>>;
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodDiscriminatedUnion<[
+        z.ZodObject<{
+            kind: z.ZodLiteral<"google_delegation">;
+            name: z.ZodString;
+            serviceAccountKey: z.ZodString;
+            domain: z.ZodString;
+            calendarEnabled: z.ZodDefault<z.ZodBoolean>;
+            contactsEnabled: z.ZodDefault<z.ZodBoolean>;
+            directoryAdmin: z.ZodOptional<z.ZodEmail>;
+            groupsEnabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>,
+        z.ZodObject<{
+            kind: z.ZodLiteral<"microsoft_app">;
+            name: z.ZodString;
+            cloud: z.ZodDefault<z.ZodEnum<{
+                global: "global";
+                "gcc-high": "gcc-high";
+                dod: "dod";
+                china: "china";
+            }>>;
+            credential: z.ZodDiscriminatedUnion<[
+                z.ZodObject<{
+                    type: z.ZodLiteral<"platform">;
+                }, z.core.$strip>,
+                z.ZodObject<{
+                    type: z.ZodLiteral<"client_secret">;
+                    clientId: z.ZodString;
+                    clientSecret: z.ZodString;
+                }, z.core.$strip>,
+                z.ZodObject<{
+                    type: z.ZodLiteral<"certificate">;
+                    clientId: z.ZodString;
+                    certificate: z.ZodString;
+                    privateKey: z.ZodString;
+                }, z.core.$strip>
+            ], "type">;
+            directoryId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>
+    ], "kind">, z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            google_delegation: "google_delegation";
+            microsoft_app: "microsoft_app";
+        }>;
+        name: z.ZodString;
+        clientId: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            unverified: "unverified";
+            failing: "failing";
+            pending_consent: "pending_consent";
+        }>;
+        statusDetail: z.ZodNullable<z.ZodString>;
+        checkedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        google: z.ZodNullable<z.ZodObject<{
+            domain: z.ZodString;
+            serviceAccountEmail: z.ZodString;
+            directoryAdmin: z.ZodNullable<z.ZodString>;
+            scopes: z.ZodArray<z.ZodString>;
+            groupsEnabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        microsoft: z.ZodNullable<z.ZodObject<{
+            cloud: z.ZodEnum<{
+                global: "global";
+                "gcc-high": "gcc-high";
+                dod: "dod";
+                china: "china";
+            }>;
+            credentialType: z.ZodEnum<{
+                platform: "platform";
+                client_secret: "client_secret";
+                certificate: "certificate";
+            }>;
+            directoryId: z.ZodNullable<z.ZodString>;
+            permissions: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isRequired: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        accounts: z.ZodNumber;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, 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.";
+    }>>, {
+        provider_not_configured: {
+            status: 400;
+            message: string;
+        };
+        invalid_certificate: {
+            status: 400;
+            message: string;
+        };
+        invalid_service_account_key: {
+            status: 400;
+            message: string;
+        };
+        directory_id_not_allowed: {
+            status: 400;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            google_delegation: "google_delegation";
+            microsoft_app: "microsoft_app";
+        }>;
+        name: z.ZodString;
+        clientId: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            unverified: "unverified";
+            failing: "failing";
+            pending_consent: "pending_consent";
+        }>;
+        statusDetail: z.ZodNullable<z.ZodString>;
+        checkedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        google: z.ZodNullable<z.ZodObject<{
+            domain: z.ZodString;
+            serviceAccountEmail: z.ZodString;
+            directoryAdmin: z.ZodNullable<z.ZodString>;
+            scopes: z.ZodArray<z.ZodString>;
+            groupsEnabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        microsoft: z.ZodNullable<z.ZodObject<{
+            cloud: z.ZodEnum<{
+                global: "global";
+                "gcc-high": "gcc-high";
+                dod: "dod";
+                china: "china";
+            }>;
+            credentialType: z.ZodEnum<{
+                platform: "platform";
+                client_secret: "client_secret";
+                certificate: "certificate";
+            }>;
+            directoryId: z.ZodNullable<z.ZodString>;
+            permissions: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isRequired: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        accounts: z.ZodNumber;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, 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 org_connection_not_found: "The organization connection does not exist.";
+    }>>, Record<never, never>>;
+    update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        name: z.ZodOptional<z.ZodString>;
+        serviceAccountKey: z.ZodOptional<z.ZodString>;
+        calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+        contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+        groupsEnabled: z.ZodOptional<z.ZodBoolean>;
+        directoryAdmin: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        certificate: z.ZodOptional<z.ZodString>;
+        privateKey: z.ZodOptional<z.ZodString>;
+        directoryId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            google_delegation: "google_delegation";
+            microsoft_app: "microsoft_app";
+        }>;
+        name: z.ZodString;
+        clientId: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            unverified: "unverified";
+            failing: "failing";
+            pending_consent: "pending_consent";
+        }>;
+        statusDetail: z.ZodNullable<z.ZodString>;
+        checkedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        google: z.ZodNullable<z.ZodObject<{
+            domain: z.ZodString;
+            serviceAccountEmail: z.ZodString;
+            directoryAdmin: z.ZodNullable<z.ZodString>;
+            scopes: z.ZodArray<z.ZodString>;
+            groupsEnabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        microsoft: z.ZodNullable<z.ZodObject<{
+            cloud: z.ZodEnum<{
+                global: "global";
+                "gcc-high": "gcc-high";
+                dod: "dod";
+                china: "china";
+            }>;
+            credentialType: z.ZodEnum<{
+                platform: "platform";
+                client_secret: "client_secret";
+                certificate: "certificate";
+            }>;
+            directoryId: z.ZodNullable<z.ZodString>;
+            permissions: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                isRequired: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        accounts: z.ZodNumber;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, 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.";
+    }>>, {
+        credential_mismatch: {
+            status: 400;
+            message: string;
+        };
+        invalid_certificate: {
+            status: 400;
+            message: string;
+        };
+        invalid_service_account_key: {
+            status: 400;
+            message: string;
+        };
+        directory_id_not_allowed: {
+            status: 400;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    delete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodVoid, 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.";
+    }>>, {
+        connection_in_use: {
+            status: 409;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    consent: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        redirectUri: z.ZodURL;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        consentUrl: z.ZodURL;
+    }, 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.";
+    }>>, {
+        provider_not_configured: {
+            status: 400;
+            message: string;
+        };
+        session_required: {
+            status: 403;
+            message: string;
+        };
+        redirect_uri_not_allowed: {
+            status: 400;
+            message: string;
+        };
+        not_microsoft: {
+            status: 400;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    test: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        user: z.ZodOptional<z.ZodEmail>;
+    }, z.core.$strip>, z.ZodObject<{
+        connection: z.ZodObject<{
+            id: z.ZodUUID;
+            kind: z.ZodEnum<{
+                google_delegation: "google_delegation";
+                microsoft_app: "microsoft_app";
+            }>;
+            name: z.ZodString;
+            clientId: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                unverified: "unverified";
+                failing: "failing";
+                pending_consent: "pending_consent";
+            }>;
+            statusDetail: z.ZodNullable<z.ZodString>;
+            checkedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+            google: z.ZodNullable<z.ZodObject<{
+                domain: z.ZodString;
+                serviceAccountEmail: z.ZodString;
+                directoryAdmin: z.ZodNullable<z.ZodString>;
+                scopes: z.ZodArray<z.ZodString>;
+                groupsEnabled: z.ZodBoolean;
+            }, z.core.$strip>>;
+            microsoft: z.ZodNullable<z.ZodObject<{
+                cloud: z.ZodEnum<{
+                    global: "global";
+                    "gcc-high": "gcc-high";
+                    dod: "dod";
+                    china: "china";
+                }>;
+                credentialType: z.ZodEnum<{
+                    platform: "platform";
+                    client_secret: "client_secret";
+                    certificate: "certificate";
+                }>;
+                directoryId: z.ZodNullable<z.ZodString>;
+                permissions: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    isRequired: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            accounts: z.ZodNumber;
+            createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+            updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        }, z.core.$strip>;
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            isOk: z.ZodBoolean;
+            isRequired: z.ZodBoolean;
+            detail: z.ZodString;
+        }, 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.";
+    }>>, {
+        user_required: {
+            status: 400;
+            message: string;
+        };
+        consent_required: {
+            status: 409;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    directoryEntries: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        query: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodString;
+            displayName: z.ZodNullable<z.ZodString>;
+            accountId: z.ZodNullable<z.ZodUUID>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, 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.";
+    }>>, {
+        directory_unavailable: {
+            status: 409;
+            message: string;
+        };
+        provider_not_found: {
+            status: 404;
+            message: string;
+        };
+        provider_rejected: {
+            status: 400;
+            message: string;
+        };
+        provider_unavailable: {
+            status: 502;
+            message: string;
+        };
+        provider_throttled: {
+            status: 429;
+            message: string;
+        };
+        invalid_cursor: {
+            status: 400;
+            message: string;
+        };
+        consent_required: {
+            status: 409;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    addAccounts: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        mailboxes: z.ZodArray<z.ZodObject<{
+            email: z.ZodEmail;
+            displayName: z.ZodOptional<z.ZodString>;
+            externalRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        settings: z.ZodOptional<z.ZodObject<{
+            bodyStorage: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>>;
+            syncWindowDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mailEnabled: z.ZodOptional<z.ZodBoolean>;
+            calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+            contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+            undoSendSeconds: z.ZodOptional<z.ZodNumber>;
+            trackOpens: z.ZodOptional<z.ZodBoolean>;
+            trackClicks: z.ZodOptional<z.ZodBoolean>;
+            trackingHoneypot: z.ZodOptional<z.ZodBoolean>;
+            suppressionCheck: z.ZodOptional<z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>>;
+            sendsPerMinute: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            email: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                created: "created";
+                exists: "exists";
+            }>;
+            accountId: z.ZodNullable<z.ZodUUID>;
+            error: z.ZodNullable<z.ZodObject<{
+                reason: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+        }, 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.";
+    }>>, {
+        billing_past_due: {
+            status: 402;
+            message: string;
+        };
+        plan_limit_storage: import("../errors.js").DeclaredError<"plan_limit_storage">;
+        storage_unavailable: {
+            status: 400;
+            message: string;
+        };
+        consent_required: {
+            status: 409;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+    addGroup: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        connectionId: z.ZodUUID;
+        email: z.ZodEmail;
+        relayEmail: z.ZodEmail;
+        displayName: z.ZodOptional<z.ZodString>;
+        externalRef: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodObject<{
+            bodyStorage: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>>;
+            syncWindowDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mailEnabled: z.ZodOptional<z.ZodBoolean>;
+            calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+            contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+            undoSendSeconds: z.ZodOptional<z.ZodNumber>;
+            trackOpens: z.ZodOptional<z.ZodBoolean>;
+            trackClicks: z.ZodOptional<z.ZodBoolean>;
+            trackingHoneypot: z.ZodOptional<z.ZodBoolean>;
+            suppressionCheck: z.ZodOptional<z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>>;
+            sendsPerMinute: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        externalRef: z.ZodNullable<z.ZodString>;
+        provider: z.ZodEnum<{
+            gmail: "gmail";
+            graph: "graph";
+            imap: "imap";
+        }>;
+        email: z.ZodString;
+        displayName: z.ZodNullable<z.ZodString>;
+        oauthAppId: z.ZodNullable<z.ZodUUID>;
+        cloud: z.ZodNullable<z.ZodEnum<{
+            global: "global";
+            "gcc-high": "gcc-high";
+            dod: "dod";
+            china: "china";
+        }>>;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            reauth_required: "reauth_required";
+            disabled: "disabled";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        settings: z.ZodObject<{
+            bodyStorage: z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>;
+            syncWindowDays: z.ZodNullable<z.ZodNumber>;
+            mailEnabled: z.ZodBoolean;
+            calendarEnabled: z.ZodBoolean;
+            contactsEnabled: z.ZodBoolean;
+            undoSendSeconds: z.ZodNumber;
+            trackOpens: z.ZodBoolean;
+            trackClicks: z.ZodBoolean;
+            trackingHoneypot: z.ZodBoolean;
+            suppressionCheck: z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>;
+            sendsPerMinute: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        settingsOverride: z.ZodObject<{
+            bodyStorage: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>>;
+            syncWindowDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mailEnabled: z.ZodOptional<z.ZodBoolean>;
+            calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+            contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+            undoSendSeconds: z.ZodOptional<z.ZodNumber>;
+            trackOpens: z.ZodOptional<z.ZodBoolean>;
+            trackClicks: z.ZodOptional<z.ZodBoolean>;
+            trackingHoneypot: z.ZodOptional<z.ZodBoolean>;
+            suppressionCheck: z.ZodOptional<z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>>;
+            sendsPerMinute: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>;
+        runtime: z.ZodNullable<z.ZodObject<{
+            state: z.ZodEnum<{
+                error: "error";
+                pending: "pending";
+                connecting: "connecting";
+                connected: "connected";
+                stopped: "stopped";
+            }>;
+            detail: z.ZodNullable<z.ZodString>;
+            ownerInstanceId: z.ZodNullable<z.ZodUUID>;
+            updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        }, z.core.$strip>>;
+        imap: z.ZodNullable<z.ZodObject<{
+            imap: z.ZodObject<{
+                host: z.ZodString;
+                port: z.ZodNumber;
+                security: z.ZodEnum<{
+                    none: "none";
+                    tls: "tls";
+                    starttls: "starttls";
+                }>;
+                user: z.ZodString;
+            }, z.core.$strip>;
+            smtp: z.ZodNullable<z.ZodObject<{
+                host: z.ZodString;
+                port: z.ZodNumber;
+                security: z.ZodEnum<{
+                    none: "none";
+                    tls: "tls";
+                    starttls: "starttls";
+                }>;
+                user: z.ZodString;
+            }, z.core.$strip>>;
+            auth: z.ZodEnum<{
+                google: "google";
+                microsoft: "microsoft";
+                password: "password";
+            }>;
+            appendSent: z.ZodBoolean;
+            dav: z.ZodNullable<z.ZodObject<{
+                calendarUrl: z.ZodNullable<z.ZodString>;
+                contactsUrl: z.ZodNullable<z.ZodString>;
+                user: z.ZodString;
+                auth: z.ZodEnum<{
+                    imap_password: "imap_password";
+                    dav_password: "dav_password";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        auth: z.ZodObject<{
+            method: z.ZodEnum<{
+                password: "password";
+                oauth: "oauth";
+                google_delegation: "google_delegation";
+                microsoft_app: "microsoft_app";
+                shared_mailbox: "shared_mailbox";
+                google_group: "google_group";
+            }>;
+            orgConnectionId: z.ZodNullable<z.ZodUUID>;
+            delegateAccountId: z.ZodNullable<z.ZodUUID>;
+            relayEmail: z.ZodNullable<z.ZodEmail>;
+        }, z.core.$strip>;
+        initializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        calendarInitializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        contactsInitializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, 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.";
+    }>>, {
+        account_exists: {
+            status: 409;
+            message: string;
+        };
+        scope_missing: {
+            status: 400;
+            message: string;
+        };
+        group_unsupported: {
+            status: 400;
+            message: string;
+        };
+        group_relay_inaccessible: {
+            status: 422;
+            message: string;
+        };
+        group_alias_unverified: {
+            status: 409;
+            message: string;
+        };
+        provider_unavailable: {
+            status: 502;
+            message: string;
+        };
+        provider_throttled: {
+            status: 429;
+            message: string;
+        };
+        billing_past_due: {
+            status: 402;
+            message: string;
+        };
+        plan_limit_accounts: import("../errors.js").DeclaredError<"plan_limit_accounts">;
+        plan_required: import("../errors.js").DeclaredError<"plan_required">;
+        spend_cap_reached: import("../errors.js").DeclaredError<"spend_cap_reached">;
+        plan_limit_storage: import("../errors.js").DeclaredError<"plan_limit_storage">;
+        storage_unavailable: {
+            status: 400;
+            message: string;
+        };
+        plan_module_unavailable: {
+            status: 403;
+            message: string;
+        };
+        org_connection_not_found: {
+            status: 404;
+            message: string;
+        };
+    }>, Record<never, never>>;
+};
+export declare const sharedMailboxes: {
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        accountId: z.ZodUUID;
+        email: z.ZodEmail;
+        displayName: z.ZodOptional<z.ZodString>;
+        externalRef: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodObject<{
+            bodyStorage: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>>;
+            syncWindowDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mailEnabled: z.ZodOptional<z.ZodBoolean>;
+            calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+            contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+            undoSendSeconds: z.ZodOptional<z.ZodNumber>;
+            trackOpens: z.ZodOptional<z.ZodBoolean>;
+            trackClicks: z.ZodOptional<z.ZodBoolean>;
+            trackingHoneypot: z.ZodOptional<z.ZodBoolean>;
+            suppressionCheck: z.ZodOptional<z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>>;
+            sendsPerMinute: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        externalRef: z.ZodNullable<z.ZodString>;
+        provider: z.ZodEnum<{
+            gmail: "gmail";
+            graph: "graph";
+            imap: "imap";
+        }>;
+        email: z.ZodString;
+        displayName: z.ZodNullable<z.ZodString>;
+        oauthAppId: z.ZodNullable<z.ZodUUID>;
+        cloud: z.ZodNullable<z.ZodEnum<{
+            global: "global";
+            "gcc-high": "gcc-high";
+            dod: "dod";
+            china: "china";
+        }>>;
+        status: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            reauth_required: "reauth_required";
+            disabled: "disabled";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        settings: z.ZodObject<{
+            bodyStorage: z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>;
+            syncWindowDays: z.ZodNullable<z.ZodNumber>;
+            mailEnabled: z.ZodBoolean;
+            calendarEnabled: z.ZodBoolean;
+            contactsEnabled: z.ZodBoolean;
+            undoSendSeconds: z.ZodNumber;
+            trackOpens: z.ZodBoolean;
+            trackClicks: z.ZodBoolean;
+            trackingHoneypot: z.ZodBoolean;
+            suppressionCheck: z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>;
+            sendsPerMinute: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        settingsOverride: z.ZodObject<{
+            bodyStorage: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                cache: "cache";
+                full: "full";
+            }>>;
+            syncWindowDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            mailEnabled: z.ZodOptional<z.ZodBoolean>;
+            calendarEnabled: z.ZodOptional<z.ZodBoolean>;
+            contactsEnabled: z.ZodOptional<z.ZodBoolean>;
+            undoSendSeconds: z.ZodOptional<z.ZodNumber>;
+            trackOpens: z.ZodOptional<z.ZodBoolean>;
+            trackClicks: z.ZodOptional<z.ZodBoolean>;
+            trackingHoneypot: z.ZodOptional<z.ZodBoolean>;
+            suppressionCheck: z.ZodOptional<z.ZodEnum<{
+                lists: "lists";
+                always: "always";
+            }>>;
+            sendsPerMinute: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>;
+        runtime: z.ZodNullable<z.ZodObject<{
+            state: z.ZodEnum<{
+                error: "error";
+                pending: "pending";
+                connecting: "connecting";
+                connected: "connected";
+                stopped: "stopped";
+            }>;
+            detail: z.ZodNullable<z.ZodString>;
+            ownerInstanceId: z.ZodNullable<z.ZodUUID>;
+            updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        }, z.core.$strip>>;
+        imap: z.ZodNullable<z.ZodObject<{
+            imap: z.ZodObject<{
+                host: z.ZodString;
+                port: z.ZodNumber;
+                security: z.ZodEnum<{
+                    none: "none";
+                    tls: "tls";
+                    starttls: "starttls";
+                }>;
+                user: z.ZodString;
+            }, z.core.$strip>;
+            smtp: z.ZodNullable<z.ZodObject<{
+                host: z.ZodString;
+                port: z.ZodNumber;
+                security: z.ZodEnum<{
+                    none: "none";
+                    tls: "tls";
+                    starttls: "starttls";
+                }>;
+                user: z.ZodString;
+            }, z.core.$strip>>;
+            auth: z.ZodEnum<{
+                google: "google";
+                microsoft: "microsoft";
+                password: "password";
+            }>;
+            appendSent: z.ZodBoolean;
+            dav: z.ZodNullable<z.ZodObject<{
+                calendarUrl: z.ZodNullable<z.ZodString>;
+                contactsUrl: z.ZodNullable<z.ZodString>;
+                user: z.ZodString;
+                auth: z.ZodEnum<{
+                    imap_password: "imap_password";
+                    dav_password: "dav_password";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        auth: z.ZodObject<{
+            method: z.ZodEnum<{
+                password: "password";
+                oauth: "oauth";
+                google_delegation: "google_delegation";
+                microsoft_app: "microsoft_app";
+                shared_mailbox: "shared_mailbox";
+                google_group: "google_group";
+            }>;
+            orgConnectionId: z.ZodNullable<z.ZodUUID>;
+            delegateAccountId: z.ZodNullable<z.ZodUUID>;
+            relayEmail: z.ZodNullable<z.ZodEmail>;
+        }, z.core.$strip>;
+        initializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        calendarInitializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        contactsInitializedAt: z.ZodNullable<z.ZodPreprocess<z.ZodDate, Date>>;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+        updatedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, 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.";
+    }>>, {
+        account_exists: {
+            status: 409;
+            message: string;
+        };
+        account_not_found: {
+            status: 404;
+            message: string;
+        };
+        shared_mailbox_unsupported: {
+            status: 400;
+            message: string;
+        };
+        scope_missing: {
+            status: 400;
+            message: string;
+        };
+        shared_mailbox_inaccessible: {
+            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;
+        };
+        billing_past_due: {
+            status: 402;
+            message: string;
+        };
+        plan_limit_accounts: import("../errors.js").DeclaredError<"plan_limit_accounts">;
+        plan_required: import("../errors.js").DeclaredError<"plan_required">;
+        spend_cap_reached: import("../errors.js").DeclaredError<"spend_cap_reached">;
+        plan_limit_storage: import("../errors.js").DeclaredError<"plan_limit_storage">;
+        storage_unavailable: {
+            status: 400;
+            message: string;
+        };
+        plan_module_unavailable: {
+            status: 403;
+            message: string;
+        };
+    }>, Record<never, never>>;
+};