@astrale-domains/services 0.3.4 → 0.4.1

package/dist/schema/modules/service/functions/delete-service-secret.d.ts

@@ -8,4 +8,4 @@ export declare const deleteServiceSecret: import("@astrale-os/sdk/schema").Metho
         kind: "rejected";
         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
     };
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/delete-service-secret.js

@@ -1,11 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-import { secretName, secretOperationRejection } from '../types/index.js';
-export const deleteServiceSecret = method({
-    description: 'Delete one write-only Service secret.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({ name: secretName }),
-    output: z.union([z.strictObject({ ok: z.literal(true) }), secretOperationRejection]),
-});
+import { deleteServiceSecretContract } from '../types/service-management.js';
+export const deleteServiceSecret = method({ ...deleteServiceSecretContract, abstract: true });

package/dist/schema/modules/service/functions/delete-service.d.ts

@@ -6,4 +6,4 @@ export declare const deleteService: import("@astrale-os/sdk/schema").Method<impo
         kind: "deleting";
         retryAfterMs: number;
     };
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/delete-service.js

@@ -1,16 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-export const deleteService = method({
-    description: 'Convergently delete provider resources and the owned Service without uninstalling consumers.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({}),
-    output: z.discriminatedUnion('kind', [
-        z.strictObject({ kind: z.literal('deleted') }),
-        z.strictObject({
-            kind: z.literal('deleting'),
-            retryAfterMs: z.number().int().min(250).max(30_000),
-        }),
-    ]),
-});
+import { deleteServiceContract } from '../types/service-management.js';
+export const deleteService = method({ ...deleteServiceContract, abstract: true });

package/dist/schema/modules/service/functions/delete-worker-secret.d.ts

@@ -0,0 +1,11 @@
+export declare const deleteWorkerSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        ok: true;
+    } | {
+        kind: "rejected";
+        reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/delete-worker-secret.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { deleteServiceSecretContract } from '../types/service-management.js';
+export const deleteWorkerSecret = method({
+    ...deleteServiceSecretContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/delete-worker.d.ts

@@ -0,0 +1,9 @@
+export declare const deleteWorker: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        kind: "deleted";
+    } | {
+        kind: "deleting";
+        retryAfterMs: number;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/delete-worker.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { deleteServiceContract } from '../types/service-management.js';
+export const deleteWorker = method({
+    ...deleteServiceContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/deploy-cloudflare-worker.d.ts

@@ -70,4 +70,4 @@ export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Me
         reason: "artifact-mode-conflict" | "invalid-deployment" | "service-unavailable";
         message: string;
     };
-}, "authenticated", true, "default">>;
+}, "authenticated", true, false>>;

package/dist/schema/modules/service/functions/index.d.ts

@@ -6,3 +6,10 @@ export { listServiceSchedules } from './list-service-schedules.js';
 export { listServiceSecretNames } from './list-service-secret-names.js';
 export { replaceServiceSchedules } from './replace-service-schedules.js';
 export { setServiceSecret } from './set-service-secret.js';
+export { deleteWorkerSecret } from './delete-worker-secret.js';
+export { deleteWorker } from './delete-worker.js';
+export { listWorkerLogs } from './list-worker-logs.js';
+export { listWorkerSchedules } from './list-worker-schedules.js';
+export { listWorkerSecretNames } from './list-worker-secret-names.js';
+export { replaceWorkerSchedules } from './replace-worker-schedules.js';
+export { setWorkerSecret } from './set-worker-secret.js';

package/dist/schema/modules/service/functions/index.js

@@ -6,3 +6,10 @@ export { listServiceSchedules } from './list-service-schedules.js';
 export { listServiceSecretNames } from './list-service-secret-names.js';
 export { replaceServiceSchedules } from './replace-service-schedules.js';
 export { setServiceSecret } from './set-service-secret.js';
+export { deleteWorkerSecret } from './delete-worker-secret.js';
+export { deleteWorker } from './delete-worker.js';
+export { listWorkerLogs } from './list-worker-logs.js';
+export { listWorkerSchedules } from './list-worker-schedules.js';
+export { listWorkerSecretNames } from './list-worker-secret-names.js';
+export { replaceWorkerSchedules } from './replace-worker-schedules.js';
+export { setWorkerSecret } from './set-worker-secret.js';

package/dist/schema/modules/service/functions/list-service-logs.d.ts

@@ -9,4 +9,4 @@ export declare const listServiceLogs: import("@astrale-os/sdk/schema").Method<im
         level: string;
         line: string;
     }[];
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/list-service-logs.js

@@ -1,13 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-export const listServiceLogs = method({
-    description: 'Read recent Service runtime logs.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({
-        tail: z.number().int().min(1).max(1_000).optional(),
-        since: z.number().int().min(0).optional(),
-    }),
-    output: z.array(z.strictObject({ id: z.string(), ts: z.number(), level: z.string(), line: z.string() })),
-});
+import { listServiceLogsContract } from '../types/service-management.js';
+export const listServiceLogs = method({ ...listServiceLogsContract, abstract: true });

package/dist/schema/modules/service/functions/list-service-schedules.d.ts

@@ -1,4 +1,4 @@
 export declare const listServiceSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
     readonly mode: 'value';
     readonly value: string[];
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/list-service-schedules.js

@@ -1,10 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-export const listServiceSchedules = method({
-    description: 'List active Service cron expressions.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({}),
-    output: z.array(z.string()),
-});
+import { listServiceSchedulesContract } from '../types/service-management.js';
+export const listServiceSchedules = method({ ...listServiceSchedulesContract, abstract: true });

package/dist/schema/modules/service/functions/list-service-secret-names.d.ts

@@ -1,4 +1,4 @@
 export declare const listServiceSecretNames: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
     readonly mode: 'value';
     readonly value: string[];
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/list-service-secret-names.js

@@ -1,11 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-import { secretName } from '../types/index.js';
-export const listServiceSecretNames = method({
-    description: 'List write-only Service secret names without exposing values.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({}),
-    output: z.array(secretName),
-});
+import { listServiceSecretNamesContract } from '../types/service-management.js';
+export const listServiceSecretNames = method({ ...listServiceSecretNamesContract, abstract: true });

package/dist/schema/modules/service/functions/list-worker-logs.d.ts

@@ -0,0 +1,12 @@
+export declare const listWorkerLogs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    tail?: number | undefined;
+    since?: number | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        ts: number;
+        level: string;
+        line: string;
+    }[];
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/list-worker-logs.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { listServiceLogsContract } from '../types/service-management.js';
+export const listWorkerLogs = method({
+    ...listServiceLogsContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/list-worker-schedules.d.ts

@@ -0,0 +1,4 @@
+export declare const listWorkerSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: string[];
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/list-worker-schedules.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { listServiceSchedulesContract } from '../types/service-management.js';
+export const listWorkerSchedules = method({
+    ...listServiceSchedulesContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/list-worker-secret-names.d.ts

@@ -0,0 +1,4 @@
+export declare const listWorkerSecretNames: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: string[];
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/list-worker-secret-names.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { listServiceSecretNamesContract } from '../types/service-management.js';
+export const listWorkerSecretNames = method({
+    ...listServiceSecretNamesContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/replace-service-schedules.d.ts

@@ -8,4 +8,4 @@ export declare const replaceServiceSchedules: import("@astrale-os/sdk/schema").M
         kind: "rejected";
         reason: "invalid-schedule" | "service-unavailable";
     };
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/replace-service-schedules.js

@@ -1,16 +1,6 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
+import { replaceServiceSchedulesContract } from '../types/service-management.js';
 export const replaceServiceSchedules = method({
-    description: 'Replace the complete Service cron set.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({ crons: z.array(z.string()).max(24) }),
-    output: z.union([
-        z.strictObject({ crons: z.array(z.string()) }),
-        z.strictObject({
-            kind: z.literal('rejected'),
-            reason: z.enum(['invalid-schedule', 'service-unavailable']),
-        }),
-    ]),
+    ...replaceServiceSchedulesContract,
+    abstract: true,
 });

package/dist/schema/modules/service/functions/replace-worker-schedules.d.ts

@@ -0,0 +1,11 @@
+export declare const replaceWorkerSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    crons: string[];
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        crons: string[];
+    } | {
+        kind: "rejected";
+        reason: "invalid-schedule" | "service-unavailable";
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/replace-worker-schedules.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { replaceServiceSchedulesContract } from '../types/service-management.js';
+export const replaceWorkerSchedules = method({
+    ...replaceServiceSchedulesContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/functions/set-service-secret.d.ts

@@ -4,9 +4,9 @@ export declare const setServiceSecret: import("@astrale-os/sdk/schema").Method<i
 }, {
     readonly mode: 'value';
     readonly value: {
-        name: string;
-    } | {
         kind: "rejected";
         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+    } | {
+        name: string;
     };
-}, "authorized", false, "default">>;
+}, "authorized", false, true>>;

package/dist/schema/modules/service/functions/set-service-secret.js

@@ -1,17 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
-import { z } from 'zod';
-import { OwnService } from '../policies/own-service.js';
-import { secretName, secretOperationRejection } from '../types/index.js';
-export const setServiceSecret = method({
-    description: 'Set one write-only Service secret.',
-    auth: 'authorized',
-    policy: ({ check, self }) => check(OwnService, self),
-    input: z.strictObject({
-        name: secretName,
-        value: z
-            .string()
-            .min(1)
-            .max(64 * 1024),
-    }),
-    output: z.union([z.strictObject({ name: secretName }), secretOperationRejection]),
-});
+import { setServiceSecretContract } from '../types/service-management.js';
+export const setServiceSecret = method({ ...setServiceSecretContract, abstract: true });

package/dist/schema/modules/service/functions/set-worker-secret.d.ts

@@ -0,0 +1,12 @@
+export declare const setWorkerSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name: string;
+    value: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        kind: "rejected";
+        reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+    } | {
+        name: string;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/service/functions/set-worker-secret.js

@@ -0,0 +1,7 @@
+import { method } from '@astrale-os/sdk/schema';
+import { OwnService } from '../policies/own-service.js';
+import { setServiceSecretContract } from '../types/service-management.js';
+export const setWorkerSecret = method({
+    ...setServiceSecretContract,
+    policy: ({ check, self }) => check(OwnService, self),
+});

package/dist/schema/modules/service/states/service-lifecycle.d.ts

@@ -4,6 +4,7 @@ export declare const serviceLifecycle: import("@astrale-os/sdk/schema").StateMac
     readonly deploying: {
         readonly recordProviderDeployment: "reconciling";
         readonly failDeployment: "failed";
+        readonly rejectDeployment: "ready";
         readonly deleteService: "deleting";
     };
     readonly reconciling: {

package/dist/schema/modules/service/states/service-lifecycle.js

@@ -6,6 +6,7 @@ export const serviceLifecycle = stateMachine({
         deploying: {
             recordProviderDeployment: 'reconciling',
             failDeployment: 'failed',
+            rejectDeployment: 'ready',
             deleteService: 'deleting',
         },
         reconciling: {

package/dist/schema/modules/service/types/deploy-cloudflare-worker.js

@@ -1,5 +1,7 @@
 import { z } from 'zod';
-import { artifactModule, assetBundle, resourceLimits } from '../types/index.js';
+import { artifactModule } from './service-deployment-artifact-module.js';
+import { assetBundle } from './service-deployment-assets.js';
+import { resourceLimits } from './service-deployment-resource-limits.js';
 import { serviceReadiness } from './service-readiness.js';
 export const artifact = z.strictObject({
     entry: z.string().min(1).max(256),

package/dist/schema/modules/service/types/index.d.ts

@@ -10,3 +10,4 @@ export type { ResourceLimits } from './service-deployment-resource-limits.js';
 export { secretName } from './service-secret-name.js';
 export { secretOperationRejection } from './service-secret-operation-rejection.js';
 export { serviceReadiness } from './service-readiness.js';
+export { setServiceSecretContract, deleteServiceSecretContract, listServiceSecretNamesContract, replaceServiceSchedulesContract, listServiceSchedulesContract, listServiceLogsContract, deleteServiceContract, } from './service-management.js';

package/dist/schema/modules/service/types/index.js

@@ -6,3 +6,4 @@ export { resourceLimits } from './service-deployment-resource-limits.js';
 export { secretName } from './service-secret-name.js';
 export { secretOperationRejection } from './service-secret-operation-rejection.js';
 export { serviceReadiness } from './service-readiness.js';
+export { setServiceSecretContract, deleteServiceSecretContract, listServiceSecretNamesContract, replaceServiceSchedulesContract, listServiceSchedulesContract, listServiceLogsContract, deleteServiceContract, } from './service-management.js';

package/dist/schema/modules/service/types/service-management.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const setServiceSecretContract: {
+    readonly description: 'Set one write-only Service secret.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>;
+    readonly output: z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            "binding-unavailable": "binding-unavailable";
+            "invalid-secret-name": "invalid-secret-name";
+            "service-unavailable": "service-unavailable";
+        }>;
+    }, z.core.$strict>]>;
+};
+export declare const deleteServiceSecretContract: {
+    readonly description: 'Delete one write-only Service secret.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>;
+    readonly output: z.ZodUnion<readonly [z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            "binding-unavailable": "binding-unavailable";
+            "invalid-secret-name": "invalid-secret-name";
+            "service-unavailable": "service-unavailable";
+        }>;
+    }, z.core.$strict>]>;
+};
+export declare const listServiceSecretNamesContract: {
+    readonly description: 'List write-only Service secret names without exposing values.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{}, z.core.$strict>;
+    readonly output: z.ZodArray<z.ZodString>;
+};
+export declare const replaceServiceSchedulesContract: {
+    readonly description: 'Replace the complete Service cron set.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{
+        crons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    readonly output: z.ZodUnion<readonly [z.ZodObject<{
+        crons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            "invalid-schedule": "invalid-schedule";
+            "service-unavailable": "service-unavailable";
+        }>;
+    }, z.core.$strict>]>;
+};
+export declare const listServiceSchedulesContract: {
+    readonly description: 'List active Service cron expressions.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{}, z.core.$strict>;
+    readonly output: z.ZodArray<z.ZodString>;
+};
+export declare const listServiceLogsContract: {
+    readonly description: 'Read recent Service runtime logs.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{
+        tail: z.ZodOptional<z.ZodNumber>;
+        since: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly output: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ts: z.ZodNumber;
+        level: z.ZodString;
+        line: z.ZodString;
+    }, z.core.$strict>>;
+};
+export declare const deleteServiceContract: {
+    readonly description: 'Convergently delete provider resources and the owned Service without uninstalling consumers.';
+    readonly auth: 'authorized';
+    readonly input: z.ZodObject<{}, z.core.$strict>;
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"deleted">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"deleting">;
+        retryAfterMs: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+};

package/dist/schema/modules/service/types/service-management.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { secretName } from './service-secret-name.js';
+import { secretOperationRejection } from './service-secret-operation-rejection.js';
+export const setServiceSecretContract = {
+    description: 'Set one write-only Service secret.',
+    auth: 'authorized',
+    input: z.strictObject({
+        name: secretName,
+        value: z
+            .string()
+            .min(1)
+            .max(64 * 1024),
+    }),
+    output: z.union([z.strictObject({ name: secretName }), secretOperationRejection]),
+};
+export const deleteServiceSecretContract = {
+    description: 'Delete one write-only Service secret.',
+    auth: 'authorized',
+    input: z.strictObject({ name: secretName }),
+    output: z.union([z.strictObject({ ok: z.literal(true) }), secretOperationRejection]),
+};
+export const listServiceSecretNamesContract = {
+    description: 'List write-only Service secret names without exposing values.',
+    auth: 'authorized',
+    input: z.strictObject({}),
+    output: z.array(secretName),
+};
+export const replaceServiceSchedulesContract = {
+    description: 'Replace the complete Service cron set.',
+    auth: 'authorized',
+    input: z.strictObject({ crons: z.array(z.string()).max(24) }),
+    output: z.union([
+        z.strictObject({ crons: z.array(z.string()) }),
+        z.strictObject({
+            kind: z.literal('rejected'),
+            reason: z.enum(['invalid-schedule', 'service-unavailable']),
+        }),
+    ]),
+};
+export const listServiceSchedulesContract = {
+    description: 'List active Service cron expressions.',
+    auth: 'authorized',
+    input: z.strictObject({}),
+    output: z.array(z.string()),
+};
+export const listServiceLogsContract = {
+    description: 'Read recent Service runtime logs.',
+    auth: 'authorized',
+    input: z.strictObject({
+        tail: z.number().int().min(1).max(1_000).optional(),
+        since: z.number().int().min(0).optional(),
+    }),
+    output: z.array(z.strictObject({ id: z.string(), ts: z.number(), level: z.string(), line: z.string() })),
+};
+export const deleteServiceContract = {
+    description: 'Convergently delete provider resources and the owned Service without uninstalling consumers.',
+    auth: 'authorized',
+    input: z.strictObject({}),
+    output: z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('deleted') }),
+        z.strictObject({
+            kind: z.literal('deleting'),
+            retryAfterMs: z.number().int().min(250).max(30_000),
+        }),
+    ]),
+};