@spacefast/common 0.0.5 → 0.0.7

package/dist/contracts/mcp.d.ts

@@ -51,8 +51,8 @@ export declare const hostedMcpApprovalSchema: z.ZodObject<{
     status: z.ZodEnum<{
         expired: "expired";
         pending: "pending";
-        denied: "denied";
         approved: "approved";
+        denied: "denied";
         consumed: "consumed";
     }>;
     decision: z.ZodNullable<z.ZodEnum<{
@@ -167,8 +167,8 @@ export declare const hostedMcpExecutionRunSchema: z.ZodObject<{
 export declare const hostedMcpToolPolicySchema: z.ZodObject<{
     tool: z.ZodString;
     runtime: z.ZodEnum<{
-        hosted: "hosted";
         "on-device": "on-device";
+        hosted: "hosted";
         both: "both";
     }>;
     category: z.ZodString;
@@ -191,8 +191,8 @@ export declare const hostedMcpPolicyDefaultsSchema: z.ZodObject<{
     toolPolicies: z.ZodArray<z.ZodObject<{
         tool: z.ZodString;
         runtime: z.ZodEnum<{
-            hosted: "hosted";
             "on-device": "on-device";
+            hosted: "hosted";
             both: "both";
         }>;
         category: z.ZodString;
@@ -257,8 +257,8 @@ export declare const hostedMcpDashboardSchema: z.ZodObject<{
         toolPolicies: z.ZodArray<z.ZodObject<{
             tool: z.ZodString;
             runtime: z.ZodEnum<{
-                hosted: "hosted";
                 "on-device": "on-device";
+                hosted: "hosted";
                 both: "both";
             }>;
             category: z.ZodString;
@@ -314,8 +314,8 @@ export declare const hostedMcpDashboardSchema: z.ZodObject<{
         status: z.ZodEnum<{
             expired: "expired";
             pending: "pending";
-            denied: "denied";
             approved: "approved";
+            denied: "denied";
             consumed: "consumed";
         }>;
         decision: z.ZodNullable<z.ZodEnum<{
@@ -422,8 +422,8 @@ export declare const hostedMcpDashboardResponseSchema: z.ZodObject<{
             toolPolicies: z.ZodArray<z.ZodObject<{
                 tool: z.ZodString;
                 runtime: z.ZodEnum<{
-                    hosted: "hosted";
                     "on-device": "on-device";
+                    hosted: "hosted";
                     both: "both";
                 }>;
                 category: z.ZodString;
@@ -479,8 +479,8 @@ export declare const hostedMcpDashboardResponseSchema: z.ZodObject<{
             status: z.ZodEnum<{
                 expired: "expired";
                 pending: "pending";
-                denied: "denied";
                 approved: "approved";
+                denied: "denied";
                 consumed: "consumed";
             }>;
             decision: z.ZodNullable<z.ZodEnum<{
@@ -608,8 +608,8 @@ export declare const hostedMcpApprovalResponseSchema: z.ZodObject<{
         status: z.ZodEnum<{
             expired: "expired";
             pending: "pending";
-            denied: "denied";
             approved: "approved";
+            denied: "denied";
             consumed: "consumed";
         }>;
         decision: z.ZodNullable<z.ZodEnum<{
@@ -776,9 +776,7 @@ export declare const hostedMcpExecutionRunResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type HostedMcpSession = z.infer<typeof hostedMcpSessionSchema>;
-export type HostedMcpWorkspaceSummary = z.infer<typeof hostedMcpWorkspaceSummarySchema>;
 export type HostedMcpApproval = z.infer<typeof hostedMcpApprovalSchema>;
-export type HostedMcpApprovalDecisionRequest = z.infer<typeof hostedMcpApprovalDecisionRequestSchema>;
 export type HostedMcpSessionEvent = z.infer<typeof hostedMcpSessionEventSchema>;
 export type HostedMcpExecutionRun = z.infer<typeof hostedMcpExecutionRunSchema>;
 export type HostedMcpExecutionStep = z.infer<typeof hostedMcpExecutionStepSchema>;

package/dist/contracts/me.js

@@ -97,7 +97,7 @@ export const meResponseSchema = z.object({
             slug: z.string().nullable().describe("Team slug."),
             source: betaEligibleTeamSourceSchema,
         }))
-            .describe("Teams the user may join via the picker (pending invitation or auto-enroll match)."),
+            .describe("Teams the user may join via the picker (pending invitation, auto-enroll match, or Automattician access)."),
     })
         .describe("Private-beta state. Dashboards key the blocked screen on gateEnabled && !enrolled, " +
         "never on !enrolled alone — else launch-day flag-off would still block people."),

package/dist/contracts/oauth-resources.d.ts

@@ -1,9 +1,8 @@
 export declare const OAUTH_AUTHORIZATION_SERVER_PATH: "/v1/auth";
-export declare const OAUTH_RESOURCE_PATHS: {
-    readonly api: "/v1";
-    readonly mcp: "/mcp";
-};
-export type OAuthResourceKey = keyof typeof OAUTH_RESOURCE_PATHS;
+/** The API resource is a path on the api origin; the MCP resource is the whole
+ * mcp origin (`https://mcp.<domain>`), so it has no path entry here. */
+export declare const OAUTH_API_RESOURCE_PATH: "/v1";
+export type OAuthResourceKey = "api" | "mcp";
 export declare const OAUTH_API_RESOURCE_SCOPES: readonly ["teams:read", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
 export declare const OAUTH_MCP_TOOL_SCOPE: "mcp:tools";
 export declare const OAUTH_MCP_RESOURCE_SCOPES: readonly ["mcp:tools", "teams:read", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
@@ -11,20 +10,32 @@ export declare const OAUTH_PROVIDER_SCOPES: readonly ["openid", "profile", "emai
 export declare const OAUTH_RESOURCE_DEFINITIONS: {
     readonly api: {
         readonly key: "api";
-        readonly path: "/v1";
         readonly name: "Spacefast API";
         readonly accessTokenTtlSeconds: number;
         readonly allowedScopes: readonly ["teams:read", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
     };
     readonly mcp: {
         readonly key: "mcp";
-        readonly path: "/mcp";
         readonly name: "Spacefast MCP";
         readonly accessTokenTtlSeconds: number;
         readonly allowedScopes: readonly ["mcp:tools", "teams:read", "spaces:read", "spaces:write", "publish:write", "domains:read", "domains:write"];
     };
 };
-export declare function oauthResourceUrl(origin: string | URL, resource: OAuthResourceKey): string;
+/** Resource identifier for the public API: `https://api.<domain>/v1`. */
+export declare function oauthApiResourceUrl(apiOrigin: string | URL): string;
+/**
+ * Resource identifier for hosted MCP: the mcp origin itself, in RFC 8707
+ * canonical form (lowercase scheme/host, no trailing slash) — this is the
+ * exact string MCP clients send as the `resource` parameter.
+ */
+export declare function oauthMcpResourceUrl(mcpOrigin: string | URL): string;
+export declare function normalizeOAuthResourceIdentifier(resource: string): string;
+/**
+ * Derive the mcp origin from a configured api origin (`api.X` → `mcp.X`).
+ * Returns null when the api host doesn't follow the `api.` convention
+ * (loopback dev, docker test hosts) — callers fall back to the api origin.
+ */
+export declare function oauthMcpOriginFromApiOrigin(apiOrigin: string | URL): string | null;
 export declare function oauthAuthorizationServerUrl(origin: string | URL): string;
 export declare function oauthTokenEndpointUrl(origin: string | URL): string;
 export declare function oauthResourceKeyForPathname(pathname: string): OAuthResourceKey | null;

package/dist/contracts/oauth-resources.js

@@ -1,8 +1,7 @@
 export const OAUTH_AUTHORIZATION_SERVER_PATH = "/v1/auth";
-export const OAUTH_RESOURCE_PATHS = {
-    api: "/v1",
-    mcp: "/mcp",
-};
+/** The API resource is a path on the api origin; the MCP resource is the whole
+ * mcp origin (`https://mcp.<domain>`), so it has no path entry here. */
+export const OAUTH_API_RESOURCE_PATH = "/v1";
 export const OAUTH_API_RESOURCE_SCOPES = [
     "teams:read",
     "spaces:read",
@@ -27,21 +26,56 @@ export const OAUTH_PROVIDER_SCOPES = [
 export const OAUTH_RESOURCE_DEFINITIONS = {
     api: {
         key: "api",
-        path: OAUTH_RESOURCE_PATHS.api,
         name: "Spacefast API",
         accessTokenTtlSeconds: 15 * 60,
         allowedScopes: OAUTH_API_RESOURCE_SCOPES,
     },
     mcp: {
         key: "mcp",
-        path: OAUTH_RESOURCE_PATHS.mcp,
         name: "Spacefast MCP",
         accessTokenTtlSeconds: 15 * 60,
         allowedScopes: OAUTH_MCP_RESOURCE_SCOPES,
     },
 };
-export function oauthResourceUrl(origin, resource) {
-    return new URL(OAUTH_RESOURCE_PATHS[resource], origin).toString();
+/** Resource identifier for the public API: `https://api.<domain>/v1`. */
+export function oauthApiResourceUrl(apiOrigin) {
+    return new URL(OAUTH_API_RESOURCE_PATH, apiOrigin).toString();
+}
+/**
+ * Resource identifier for hosted MCP: the mcp origin itself, in RFC 8707
+ * canonical form (lowercase scheme/host, no trailing slash) — this is the
+ * exact string MCP clients send as the `resource` parameter.
+ */
+export function oauthMcpResourceUrl(mcpOrigin) {
+    return new URL(mcpOrigin).origin;
+}
+export function normalizeOAuthResourceIdentifier(resource) {
+    const trimmed = resource.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const url = new URL(trimmed);
+    if (!url.search && !url.hash && url.pathname === "/") {
+        return url.origin;
+    }
+    if (!url.search && !url.hash && url.pathname === `${OAUTH_API_RESOURCE_PATH}/`) {
+        url.pathname = OAUTH_API_RESOURCE_PATH;
+        return url.toString();
+    }
+    return url.toString();
+}
+/**
+ * Derive the mcp origin from a configured api origin (`api.X` → `mcp.X`).
+ * Returns null when the api host doesn't follow the `api.` convention
+ * (loopback dev, docker test hosts) — callers fall back to the api origin.
+ */
+export function oauthMcpOriginFromApiOrigin(apiOrigin) {
+    const url = new URL(apiOrigin);
+    if (!url.hostname.startsWith("api.")) {
+        return null;
+    }
+    url.hostname = `mcp.${url.hostname.slice("api.".length)}`;
+    return url.origin;
 }
 export function oauthAuthorizationServerUrl(origin) {
     return new URL(OAUTH_AUTHORIZATION_SERVER_PATH, origin).toString();
@@ -50,11 +84,8 @@ export function oauthTokenEndpointUrl(origin) {
     return new URL(`${OAUTH_AUTHORIZATION_SERVER_PATH}/oauth2/token`, origin).toString();
 }
 export function oauthResourceKeyForPathname(pathname) {
-    if (pathname === OAUTH_RESOURCE_PATHS.mcp) {
-        return "mcp";
-    }
-    if (pathname === OAUTH_RESOURCE_PATHS.api ||
-        pathname.startsWith(`${OAUTH_RESOURCE_PATHS.api}/`)) {
+    if (pathname === OAUTH_API_RESOURCE_PATH ||
+        pathname.startsWith(`${OAUTH_API_RESOURCE_PATH}/`)) {
         return "api";
     }
     return null;

package/dist/contracts/operations.d.ts

@@ -1,4 +1,114 @@
 import { z } from "zod";
+export declare const userOperationKindSchema: z.ZodEnum<{
+    approval: "approval";
+    version_finalize: "version_finalize";
+    version_promote_live: "version_promote_live";
+    version_delete: "version_delete";
+    build_start: "build_start";
+    domain_check: "domain_check";
+    domain_ssl_retry: "domain_ssl_retry";
+    domain_registration_submit: "domain_registration_submit";
+    domain_transfer_submit: "domain_transfer_submit";
+    domain_zone_publish: "domain_zone_publish";
+    domain_dns_apply: "domain_dns_apply";
+    domain_lifecycle: "domain_lifecycle";
+    variable_cascade: "variable_cascade";
+    webhook_deliver: "webhook_deliver";
+    integration_release: "integration_release";
+    agent_run: "agent_run";
+}>;
+export type UserOperationKind = z.infer<typeof userOperationKindSchema>;
+export declare const UserOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        canceled: "canceled";
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+    }>;
+    resources: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    progress: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            registrar: "registrar";
+            wpcloud: "wpcloud";
+            dns: "dns";
+            runtime: "runtime";
+        }>>>;
+        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        approval: "approval";
+        version_finalize: "version_finalize";
+        version_promote_live: "version_promote_live";
+        version_delete: "version_delete";
+        build_start: "build_start";
+        domain_check: "domain_check";
+        domain_ssl_retry: "domain_ssl_retry";
+        domain_registration_submit: "domain_registration_submit";
+        domain_transfer_submit: "domain_transfer_submit";
+        domain_zone_publish: "domain_zone_publish";
+        domain_dns_apply: "domain_dns_apply";
+        domain_lifecycle: "domain_lifecycle";
+        variable_cascade: "variable_cascade";
+        webhook_deliver: "webhook_deliver";
+        integration_release: "integration_release";
+        agent_run: "agent_run";
+    }>;
+    versionSource: z.ZodOptional<z.ZodEnum<{
+        direct_upload: "direct_upload";
+        git: "git";
+        settings: "settings";
+    }>>;
+    integrationRelease: z.ZodOptional<z.ZodObject<{
+        environment: z.ZodEnum<{
+            production: "production";
+            preview: "preview";
+            development: "development";
+        }>;
+    }, z.core.$strip>>;
+    agentRun: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            canceled: "canceled";
+            queued: "queued";
+            running: "running";
+            approval_required: "approval_required";
+        }>;
+        tool: z.ZodString;
+        mode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        decision: z.ZodNullable<z.ZodEnum<{
+            deny: "deny";
+            approve: "approve";
+        }>>;
+        decidedAt: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodString;
+        consumedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const operationListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
@@ -8,7 +118,6 @@ export declare const operationListQuerySchema: z.ZodObject<{
 export declare const operationListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        kind: z.ZodString;
         status: z.ZodEnum<{
             failed: "failed";
             canceled: "canceled";
@@ -46,6 +155,57 @@ export declare const operationListResponseSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         createdAt: z.ZodString;
         finishedAt: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            approval: "approval";
+            version_finalize: "version_finalize";
+            version_promote_live: "version_promote_live";
+            version_delete: "version_delete";
+            build_start: "build_start";
+            domain_check: "domain_check";
+            domain_ssl_retry: "domain_ssl_retry";
+            domain_registration_submit: "domain_registration_submit";
+            domain_transfer_submit: "domain_transfer_submit";
+            domain_zone_publish: "domain_zone_publish";
+            domain_dns_apply: "domain_dns_apply";
+            domain_lifecycle: "domain_lifecycle";
+            variable_cascade: "variable_cascade";
+            webhook_deliver: "webhook_deliver";
+            integration_release: "integration_release";
+            agent_run: "agent_run";
+        }>;
+        versionSource: z.ZodOptional<z.ZodEnum<{
+            direct_upload: "direct_upload";
+            git: "git";
+            settings: "settings";
+        }>>;
+        integrationRelease: z.ZodOptional<z.ZodObject<{
+            environment: z.ZodEnum<{
+                production: "production";
+                preview: "preview";
+                development: "development";
+            }>;
+        }, z.core.$strip>>;
+        agentRun: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                canceled: "canceled";
+                queued: "queued";
+                running: "running";
+                approval_required: "approval_required";
+            }>;
+            tool: z.ZodString;
+            mode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        approval: z.ZodOptional<z.ZodObject<{
+            decision: z.ZodNullable<z.ZodEnum<{
+                deny: "deny";
+                approve: "approve";
+            }>>;
+            decidedAt: z.ZodNullable<z.ZodString>;
+            expiresAt: z.ZodString;
+            consumedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     pagination: z.ZodObject<{
         nextCursor: z.ZodNullable<z.ZodString>;

package/dist/contracts/operations.js

@@ -1,5 +1,53 @@
 import { z } from "zod";
 import { AsyncOperationSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+export const userOperationKindSchema = z.enum([
+    "version_finalize",
+    "version_promote_live",
+    "version_delete",
+    "build_start",
+    "domain_check",
+    "domain_ssl_retry",
+    "domain_registration_submit",
+    "domain_transfer_submit",
+    "domain_zone_publish",
+    "domain_dns_apply",
+    "domain_lifecycle",
+    "variable_cascade",
+    "webhook_deliver",
+    "integration_release",
+    "agent_run",
+    "approval",
+]);
+export const UserOperationSchema = AsyncOperationSchema.extend({
+    kind: userOperationKindSchema,
+    versionSource: z
+        .enum(["direct_upload", "git", "settings"])
+        .optional()
+        .describe("Version provenance for version operations; settings marks a settings publish, while direct_upload and git mark content publishes. Omitted for legacy rows."),
+    integrationRelease: z
+        .object({
+        environment: z.enum(["production", "preview", "development"]),
+    })
+        .optional()
+        .describe("Release environment for an integration tag pointer flip."),
+    agentRun: z
+        .object({
+        state: z.enum(["queued", "running", "approval_required", "completed", "failed", "canceled"]),
+        tool: z.string(),
+        mode: z.string().optional(),
+    })
+        .optional()
+        .describe("Authoritative agent execution state and the tool invocation that produced it."),
+    approval: z
+        .object({
+        decision: z.enum(["approve", "deny"]).nullable(),
+        decidedAt: z.string().datetime().nullable(),
+        expiresAt: z.string().datetime(),
+        consumedAt: z.string().datetime().nullable(),
+    })
+        .optional()
+        .describe("Current approval decision and lifecycle timestamps from the approval authority."),
+});
 export const operationListQuerySchema = cursorListQuerySchema.extend({
     resourceType: z
         .string()
@@ -9,6 +57,6 @@ export const operationListQuerySchema = cursorListQuerySchema.extend({
     resourceId: z.string().min(1).optional().describe("Filter to operations touching one resource."),
 });
 export const operationListResponseSchema = z.object({
-    data: z.array(AsyncOperationSchema),
+    data: z.array(UserOperationSchema),
     pagination: CursorPaginationSchema,
 });

package/dist/contracts/platform.d.ts

@@ -12,101 +12,6 @@ export declare const domainPurchaseContactSchema: z.ZodObject<{
     email: z.ZodString;
     phone: z.ZodString;
 }, z.core.$strip>;
-export declare const domainContactUpdateSchema: z.ZodObject<{
-    firstName: z.ZodOptional<z.ZodString>;
-    lastName: z.ZodOptional<z.ZodString>;
-    organization: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    address1: z.ZodOptional<z.ZodString>;
-    address2: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    city: z.ZodOptional<z.ZodString>;
-    state: z.ZodOptional<z.ZodString>;
-    postalCode: z.ZodOptional<z.ZodString>;
-    countryCode: z.ZodOptional<z.ZodString>;
-    email: z.ZodOptional<z.ZodString>;
-    phone: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const domainRegistrationUpdateSchema: z.ZodObject<{
-    autoRenew: z.ZodOptional<z.ZodBoolean>;
-    privacySetting: z.ZodOptional<z.ZodEnum<{
-        enable_privacy_service: "enable_privacy_service";
-        redact_contact_info: "redact_contact_info";
-        disclose_contact_info: "disclose_contact_info";
-    }>>;
-    contactId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const domainPurchaseSchema: z.ZodObject<{
-    domain: z.ZodString;
-    contact: z.ZodObject<{
-        firstName: z.ZodString;
-        lastName: z.ZodString;
-        organization: z.ZodOptional<z.ZodString>;
-        address1: z.ZodString;
-        address2: z.ZodOptional<z.ZodString>;
-        city: z.ZodString;
-        state: z.ZodString;
-        postalCode: z.ZodString;
-        countryCode: z.ZodString;
-        email: z.ZodString;
-        phone: z.ZodString;
-    }, z.core.$strip>;
-    period: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    privacySetting: z.ZodDefault<z.ZodEnum<{
-        enable_privacy_service: "enable_privacy_service";
-        redact_contact_info: "redact_contact_info";
-        disclose_contact_info: "disclose_contact_info";
-    }>>;
-    expectedFeeAmount: z.ZodCoercedNumber<unknown>;
-}, z.core.$strip>;
-export declare const domainPurchaseCheckoutSchema: z.ZodObject<{
-    domain: z.ZodString;
-    contact: z.ZodObject<{
-        firstName: z.ZodString;
-        lastName: z.ZodString;
-        organization: z.ZodOptional<z.ZodString>;
-        address1: z.ZodString;
-        address2: z.ZodOptional<z.ZodString>;
-        city: z.ZodString;
-        state: z.ZodString;
-        postalCode: z.ZodString;
-        countryCode: z.ZodString;
-        email: z.ZodString;
-        phone: z.ZodString;
-    }, z.core.$strip>;
-    period: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    privacySetting: z.ZodDefault<z.ZodEnum<{
-        enable_privacy_service: "enable_privacy_service";
-        redact_contact_info: "redact_contact_info";
-        disclose_contact_info: "disclose_contact_info";
-    }>>;
-    expectedFeeAmount: z.ZodCoercedNumber<unknown>;
-    successUrl: z.ZodString;
-    cancelUrl: z.ZodString;
-}, z.core.$strip>;
-export declare const domainTransferSchema: z.ZodObject<{
-    domain: z.ZodString;
-    authCode: z.ZodString;
-    contact: z.ZodObject<{
-        firstName: z.ZodString;
-        lastName: z.ZodString;
-        organization: z.ZodOptional<z.ZodString>;
-        address1: z.ZodString;
-        address2: z.ZodOptional<z.ZodString>;
-        city: z.ZodString;
-        state: z.ZodString;
-        postalCode: z.ZodString;
-        countryCode: z.ZodString;
-        email: z.ZodString;
-        phone: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const domainEmailForwardSchema: z.ZodObject<{
-    mailbox: z.ZodString;
-    destination: z.ZodString;
-}, z.core.$strip>;
-export declare const domainEmailForwardUpdateSchema: z.ZodObject<{
-    mailbox: z.ZodOptional<z.ZodString>;
-    destination: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
 export declare const logWindowQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
@@ -326,6 +231,12 @@ export declare const runtimeCertificateMutationResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
+export declare const runtimeCertificateValidationResponseSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+    validations: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
 export declare const runtimeCertificateActivateSchema: z.ZodObject<{
     domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
@@ -350,10 +261,3 @@ export declare const runtimeSslActionResponseSchema: z.ZodObject<{
     domain: z.ZodString;
     raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-export declare const runtimeProviderRawResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<true>;
-    message: z.ZodNullable<z.ZodString>;
-    jobId: z.ZodNullable<z.ZodNumber>;
-    responseTicketId: z.ZodNullable<z.ZodString>;
-    raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;

package/dist/contracts/platform.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { CursorPaginationSchema, baseDiagnosticSchema, cursorListQuerySchema } from "./common.js";
-const atLeastOneKey = (value) => Object.keys(value).length > 0;
 export const domainPurchaseContactSchema = z.object({
     firstName: z.string().trim().min(1).max(80),
     lastName: z.string().trim().min(1).max(80),
@@ -14,48 +13,6 @@ export const domainPurchaseContactSchema = z.object({
     email: z.string().trim().email().max(190),
     phone: z.string().trim().min(7).max(32),
 });
-export const domainContactUpdateSchema = domainPurchaseContactSchema
-    .partial()
-    .refine(atLeastOneKey, "At least one contact field must be provided.");
-export const domainRegistrationUpdateSchema = z
-    .object({
-    autoRenew: z.boolean().optional(),
-    privacySetting: z
-        .enum(["enable_privacy_service", "redact_contact_info", "disclose_contact_info"])
-        .optional(),
-    contactId: z.string().trim().min(1).optional(),
-})
-    .refine(atLeastOneKey, "At least one registration field must be provided.");
-export const domainPurchaseSchema = z.object({
-    domain: z.string().trim().min(3).max(253),
-    contact: domainPurchaseContactSchema,
-    period: z.coerce.number().int().min(1).max(10).default(1),
-    privacySetting: z
-        .enum(["enable_privacy_service", "redact_contact_info", "disclose_contact_info"])
-        .default("enable_privacy_service"),
-    expectedFeeAmount: z.coerce.number().int().positive(),
-});
-export const domainPurchaseCheckoutSchema = domainPurchaseSchema.extend({
-    successUrl: z.string().url(),
-    cancelUrl: z.string().url(),
-});
-export const domainTransferSchema = z.object({
-    domain: z.string().trim().min(3).max(253),
-    authCode: z.string().trim().min(4).max(255),
-    contact: domainPurchaseContactSchema,
-});
-export const domainEmailForwardSchema = z.object({
-    mailbox: z
-        .string()
-        .trim()
-        .min(1)
-        .max(64)
-        .regex(/^[A-Za-z0-9._%+-]+$/),
-    destination: z.string().trim().email().max(190),
-});
-export const domainEmailForwardUpdateSchema = domainEmailForwardSchema
-    .partial()
-    .refine(atLeastOneKey, "At least one email forwarding field must be provided.");
 export const logWindowQuerySchema = cursorListQuerySchema.extend({
     since: z.string().datetime().optional().describe("Start of the log window."),
     until: z.string().datetime().optional().describe("End of the log window."),
@@ -184,6 +141,12 @@ export const runtimeCertificateMutationResponseSchema = z.object({
     certificate: runtimeCertificateSchema.nullable(),
     raw: z.record(z.string(), z.unknown()),
 });
+export const runtimeCertificateValidationResponseSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(z.string()),
+    warnings: z.array(z.string()),
+    validations: z.record(z.string(), z.record(z.string(), z.unknown())),
+});
 export const runtimeCertificateActivateSchema = z.object({
     domains: z.array(z.string()).optional(),
 });
@@ -207,10 +170,3 @@ export const runtimeSslActionResponseSchema = z.object({
     domain: z.string().min(1),
     raw: z.record(z.string(), z.unknown()),
 });
-export const runtimeProviderRawResponseSchema = z.object({
-    ok: z.literal(true),
-    message: z.string().nullable(),
-    jobId: z.number().int().nullable(),
-    responseTicketId: z.string().nullable(),
-    raw: z.record(z.string(), z.unknown()),
-});