@astrale-domains/services 0.4.5 → 0.4.7

package/dist/schema/schema.d.ts

@@ -66,7 +66,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     } | {
                         name: string;
                     };
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     name: string;
                 }, {
@@ -77,11 +77,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
                     };
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: string[];
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     crons: string[];
                 }, {
@@ -92,11 +92,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "rejected";
                         reason: "invalid-schedule" | "service-unavailable";
                     };
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: string[];
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     tail?: number | undefined;
                     since?: number | undefined;
@@ -108,7 +108,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         level: string;
                         line: string;
                     }[];
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
                 delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: {
@@ -117,7 +117,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "deleting";
                         retryAfterMs: number;
                     };
-                }, "authorized", false, true>>;
+                }, "authorized", false, true, undefined>>;
             };
         }>;
         readonly CloudflareWorker: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
@@ -187,7 +187,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         } | {
                             name: string;
                         };
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                         name: string;
                     }, {
@@ -198,11 +198,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                             kind: "rejected";
                             reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
                         };
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                         readonly mode: 'value';
                         readonly value: string[];
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                         crons: string[];
                     }, {
@@ -213,11 +213,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                             kind: "rejected";
                             reason: "invalid-schedule" | "service-unavailable";
                         };
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                         readonly mode: 'value';
                         readonly value: string[];
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                         tail?: number | undefined;
                         since?: number | undefined;
@@ -229,7 +229,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                             level: string;
                             line: string;
                         }[];
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                     delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                         readonly mode: 'value';
                         readonly value: {
@@ -238,7 +238,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                             kind: "deleting";
                             retryAfterMs: number;
                         };
-                    }, "authorized", false, true>>;
+                    }, "authorized", false, true, undefined>>;
                 };
             }>];
             readonly properties: {
@@ -274,6 +274,18 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     name?: string | undefined;
                     entry?: string | undefined;
                     modules?: ({
+                        name: string;
+                        kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        content: {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64: string;
+                        } | {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64Chunks: string[];
+                        };
+                    } | {
                         contentBase64: string;
                         name: string;
                         kind?: "data" | "esm" | "text" | "wasm" | undefined;
@@ -287,6 +299,18 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         release: {
                             entry: string;
                             modules: ({
+                                name: string;
+                                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                                content: {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64: string;
+                                } | {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64Chunks: string[];
+                                };
+                            } | {
                                 contentBase64: string;
                                 name: string;
                                 kind?: "data" | "esm" | "text" | "wasm" | undefined;
@@ -311,6 +335,18 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     secrets?: Record<string, string> | undefined;
                     assets?: {
                         files: ({
+                            path: string;
+                            contentType?: string | undefined;
+                            content: {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64: string;
+                            } | {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64Chunks: string[];
+                            };
+                        } | {
                             contentBase64: string;
                             path: string;
                             contentType?: string | undefined;
@@ -342,7 +378,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         reason: "artifact-mode-conflict" | "invalid-deployment" | "service-unavailable";
                         message: string;
                     };
-                }, "authenticated", true, false>>;
+                }, "authenticated", true, false, undefined>>;
                 migrateIngress: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     action: "complete" | "detach" | "restore";
                     probe: {
@@ -366,7 +402,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "rejected";
                         reason: "missing-location" | "not-detached" | "service-unavailable";
                     };
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     name: string;
                     value: string;
@@ -378,7 +414,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                     } | {
                         name: string;
                     };
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     name: string;
                 }, {
@@ -389,11 +425,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "rejected";
                         reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
                     };
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: string[];
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     crons: string[];
                 }, {
@@ -404,11 +440,11 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "rejected";
                         reason: "invalid-schedule" | "service-unavailable";
                     };
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: string[];
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     tail?: number | undefined;
                     since?: number | undefined;
@@ -420,7 +456,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         level: string;
                         line: string;
                     }[];
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
                 delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
                     readonly mode: 'value';
                     readonly value: {
@@ -429,7 +465,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
                         kind: "deleting";
                         retryAfterMs: number;
                     };
-                }, "authorized", false, false>>;
+                }, "authorized", false, false, undefined>>;
             };
             readonly policies: {
                 read: import("@astrale-os/sdk/schema").Policy;
@@ -451,10 +487,691 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"se
             readonly constraints: Record<never, never>;
             readonly effectiveProperties: never;
         }>;
+        readonly DeploymentLine: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly description: "The deployment line of one origin in one environment, held by one organisation.";
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+            readonly properties: {
+                origin: import("zod").ZodString;
+                environment: import("zod").ZodString;
+                fingerprint: import("zod").ZodString;
+                line: import("zod").ZodString;
+            };
+            readonly policies: {
+                read: () => import("@astrale-os/sdk/schema").Policy;
+            };
+        }>;
+        readonly Deployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly abstract: true;
+            readonly description: "One immutable deployment of a release on a publisher line.";
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+            readonly properties: {
+                label: import("zod").ZodString;
+                url: import("zod").ZodString;
+                state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+                    readonly deploying: {
+                        readonly activate: "active";
+                        readonly fail: "failed";
+                    };
+                    readonly active: {
+                        readonly retire: "retiring";
+                    };
+                    readonly retiring: {
+                        readonly completeRetirement: "retired";
+                    };
+                    readonly retired: {
+                        readonly revive: "deploying";
+                    };
+                    readonly failed: {
+                        readonly retry: "deploying";
+                        readonly retire: "retiring";
+                    };
+                }, "deploying">, {
+                    required?: boolean;
+                    description?: string;
+                }>;
+                retention: import("zod").ZodEnum<{
+                    preview: "preview";
+                    published: "published";
+                }>;
+                record: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"astrale.deployment-record">;
+                    version: import("zod").ZodLiteral<1>;
+                    origin: import("zod").ZodString;
+                    environment: import("zod").ZodString;
+                    releaseDigest: import("zod").ZodString;
+                    buildDigest: import("zod").ZodString;
+                    schemaRevision: import("zod").ZodString;
+                    configuration: import("zod").ZodString;
+                    providerScript: import("zod").ZodString;
+                    commit: import("zod").ZodNullable<import("zod").ZodObject<{
+                        sha: import("zod").ZodString;
+                        dirty: import("zod").ZodBoolean;
+                        base: import("zod").ZodOptional<import("zod").ZodObject<{
+                            version: import("zod").ZodString;
+                            distance: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>;
+                configuration: import("zod").ZodObject<{
+                    format: import("zod").ZodLiteral<"astrale.deployment.configuration">;
+                    version: import("zod").ZodLiteral<1>;
+                    vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                    settings: import("zod").ZodObject<{
+                        maximumRequestBytes: import("zod").ZodNumber;
+                        invocationTimeoutMs: import("zod").ZodNumber;
+                        tokenExchange: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                            maximumLifetimeSeconds: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>]>;
+                        durableOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                            retentionMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                                initialIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                maxAttempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                maxIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strict>>;
+                            stepTimeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    runtime: import("zod").ZodObject<{
+                        compatibilityDate: import("zod").ZodString;
+                        compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
+                    bindings: import("zod").ZodObject<{
+                        services: import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            service: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                        dispatchNamespaces: import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            namespace: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>>;
+                        secrets: import("zod").ZodArray<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>;
+                    router: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                        service: import("zod").ZodString;
+                        hostSuffix: import("zod").ZodString;
+                        minLabels: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>]>;
+                }, import("zod/v4/core").$strict>;
+                secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    digest: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>, {
+                    readonly required: false;
+                }>;
+                scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                    readonly required: false;
+                }>;
+                signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                    readonly required: false;
+                }>;
+                activatedAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
+                lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
+                expiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
+                retiredAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
+                retirement: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodEnum<{
+                    expired: "expired";
+                    withdrawn: "withdrawn";
+                }>, {
+                    readonly required: false;
+                }>;
+                operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                    readonly required: false;
+                }>;
+                operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                    readonly type: 'string';
+                    readonly 'x-astrale-value-kind': 'instant';
+                }>, {
+                    readonly required: false;
+                }>;
+            };
+            readonly methods: {
+                setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    value: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        name: string;
+                    } | {
+                        kind: "rejected";
+                        reason: "secret-undeclared" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, true, undefined>>;
+                secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, true, undefined>>;
+            };
+        }>;
+        readonly CloudflareDeployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly description: "One Deployment uploaded as the Workers for Platforms script its label names.";
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+                readonly abstract: true;
+                readonly description: "One immutable deployment of a release on a publisher line.";
+                readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+                readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+                readonly properties: {
+                    label: import("zod").ZodString;
+                    url: import("zod").ZodString;
+                    state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+                        readonly deploying: {
+                            readonly activate: "active";
+                            readonly fail: "failed";
+                        };
+                        readonly active: {
+                            readonly retire: "retiring";
+                        };
+                        readonly retiring: {
+                            readonly completeRetirement: "retired";
+                        };
+                        readonly retired: {
+                            readonly revive: "deploying";
+                        };
+                        readonly failed: {
+                            readonly retry: "deploying";
+                            readonly retire: "retiring";
+                        };
+                    }, "deploying">, {
+                        required?: boolean;
+                        description?: string;
+                    }>;
+                    retention: import("zod").ZodEnum<{
+                        preview: "preview";
+                        published: "published";
+                    }>;
+                    record: import("zod").ZodObject<{
+                        format: import("zod").ZodLiteral<"astrale.deployment-record">;
+                        version: import("zod").ZodLiteral<1>;
+                        origin: import("zod").ZodString;
+                        environment: import("zod").ZodString;
+                        releaseDigest: import("zod").ZodString;
+                        buildDigest: import("zod").ZodString;
+                        schemaRevision: import("zod").ZodString;
+                        configuration: import("zod").ZodString;
+                        providerScript: import("zod").ZodString;
+                        commit: import("zod").ZodNullable<import("zod").ZodObject<{
+                            sha: import("zod").ZodString;
+                            dirty: import("zod").ZodBoolean;
+                            base: import("zod").ZodOptional<import("zod").ZodObject<{
+                                version: import("zod").ZodString;
+                                distance: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>;
+                    configuration: import("zod").ZodObject<{
+                        format: import("zod").ZodLiteral<"astrale.deployment.configuration">;
+                        version: import("zod").ZodLiteral<1>;
+                        vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                        settings: import("zod").ZodObject<{
+                            maximumRequestBytes: import("zod").ZodNumber;
+                            invocationTimeoutMs: import("zod").ZodNumber;
+                            tokenExchange: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                                maximumLifetimeSeconds: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strict>]>;
+                            durableOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                                retentionMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                                    initialIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                    maxAttempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                    maxIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                                }, import("zod/v4/core").$strict>>;
+                                stepTimeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>;
+                        runtime: import("zod").ZodObject<{
+                            compatibilityDate: import("zod").ZodString;
+                            compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        bindings: import("zod").ZodObject<{
+                            services: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                service: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                            dispatchNamespaces: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                namespace: import("zod").ZodString;
+                            }, import("zod/v4/core").$strict>>;
+                            secrets: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        router: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                            service: import("zod").ZodString;
+                            hostSuffix: import("zod").ZodString;
+                            minLabels: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strict>]>;
+                    }, import("zod/v4/core").$strict>;
+                    secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        digest: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>, {
+                        readonly required: false;
+                    }>;
+                    scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                        readonly required: false;
+                    }>;
+                    signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                        readonly required: false;
+                    }>;
+                    activatedAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
+                    lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
+                    expiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
+                    retiredAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
+                    retirement: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodEnum<{
+                        expired: "expired";
+                        withdrawn: "withdrawn";
+                    }>, {
+                        readonly required: false;
+                    }>;
+                    operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                        readonly required: false;
+                    }>;
+                    operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                        readonly type: 'string';
+                        readonly 'x-astrale-value-kind': 'instant';
+                    }>, {
+                        readonly required: false;
+                    }>;
+                };
+                readonly methods: {
+                    setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                        name: string;
+                        value: string;
+                    }, {
+                        readonly mode: 'value';
+                        readonly value: {
+                            name: string;
+                        } | {
+                            kind: "rejected";
+                            reason: "secret-undeclared" | "service-unavailable";
+                            message: string;
+                            retryAfter?: string | undefined;
+                        };
+                    }, "authenticated", false, true, undefined>>;
+                    secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                        readonly mode: 'value';
+                        readonly value: string[];
+                    }, "authenticated", false, true, undefined>>;
+                };
+            }>];
+            readonly methods: {
+                deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    format: "astrale.services.deployment-request";
+                    version: 1;
+                    organization?: string | undefined;
+                    origin: string;
+                    environment: string;
+                    addressing: "opaque" | "readable";
+                    label: string;
+                    buildDigest: string;
+                    configuration: {
+                        format: "astrale.deployment.configuration";
+                        version: 1;
+                        vars: Record<string, string>;
+                        settings: {
+                            maximumRequestBytes: number;
+                            invocationTimeoutMs: number;
+                            tokenExchange: false | {
+                                maximumLifetimeSeconds: number;
+                            };
+                            durableOptions?: {
+                                retentionMs?: number | undefined;
+                                retry?: {
+                                    initialIntervalMs?: number | undefined;
+                                    maxAttempts?: number | undefined;
+                                    maxIntervalMs?: number | undefined;
+                                } | undefined;
+                                stepTimeoutMs?: number | undefined;
+                            } | undefined;
+                        };
+                        runtime: {
+                            compatibilityDate: string;
+                            compatibilityFlags: string[];
+                        };
+                        bindings: {
+                            services: {
+                                name: string;
+                                service: string;
+                            }[];
+                            dispatchNamespaces: {
+                                name: string;
+                                namespace: string;
+                            }[];
+                            secrets: string[];
+                        };
+                        router: false | {
+                            service: string;
+                            hostSuffix: string;
+                            minLabels: number;
+                        };
+                    };
+                    record: {
+                        releaseDigest: string;
+                        schemaRevision: string;
+                        schemaBundle: string;
+                        commit: {
+                            sha: string;
+                            dirty: boolean;
+                            base?: {
+                                version: string;
+                                distance: number;
+                            } | undefined;
+                        } | null;
+                    };
+                    bundle: {
+                        entrypoint: string;
+                        modules: ({
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                            content: {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64: string;
+                            } | {
+                                encoding: "gzip" | "identity";
+                                decodedSize: number;
+                                contentBase64Chunks: string[];
+                            };
+                        } | {
+                            contentBase64: string;
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        } | {
+                            contentBase64Chunks: string[];
+                            name: string;
+                            kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                        })[];
+                        assets?: {
+                            files: ({
+                                path: string;
+                                contentType?: string | undefined;
+                                content: {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64: string;
+                                } | {
+                                    encoding: "gzip" | "identity";
+                                    decodedSize: number;
+                                    contentBase64Chunks: string[];
+                                };
+                            } | {
+                                contentBase64: string;
+                                path: string;
+                                contentType?: string | undefined;
+                            } | {
+                                contentBase64Chunks: string[];
+                                path: string;
+                                contentType?: string | undefined;
+                            })[];
+                            notFound?: "404-page" | "none" | "single-page-application" | undefined;
+                            runWorkerFirst?: boolean | undefined;
+                            htmlHandling?: "none" | undefined;
+                        } | undefined;
+                    };
+                    secrets: Record<string, string>;
+                    readiness?: {
+                        paths: string[];
+                    } | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        kind: "rejected";
+                        reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    } | {
+                        kind: "deployed";
+                        state: "created" | "reused";
+                        secrets: {
+                            state: "bound" | "unchanged" | "updated";
+                        };
+                        deployment: {
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: {
+                                format: "astrale.deployment-record";
+                                version: 1;
+                                origin: string;
+                                environment: string;
+                                releaseDigest: string;
+                                buildDigest: string;
+                                schemaRevision: string;
+                                configuration: string;
+                                providerScript: string;
+                                commit: {
+                                    sha: string;
+                                    dirty: boolean;
+                                    base?: {
+                                        version: string;
+                                        distance: number;
+                                    } | undefined;
+                                } | null;
+                            };
+                        };
+                    };
+                }, "authenticated", true, false, undefined>>;
+                hosting: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        routingDomain: string;
+                        addressing: "opaque" | "readable";
+                    };
+                }, "authenticated", true, false, undefined>>;
+                list: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    origin?: string | undefined;
+                    environment?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        deployments: ({
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: {
+                                format: "astrale.deployment-record";
+                                version: 1;
+                                origin: string;
+                                environment: string;
+                                releaseDigest: string;
+                                buildDigest: string;
+                                schemaRevision: string;
+                                configuration: string;
+                                providerScript: string;
+                                commit: {
+                                    sha: string;
+                                    dirty: boolean;
+                                    base?: {
+                                        version: string;
+                                        distance: number;
+                                    } | undefined;
+                                } | null;
+                            };
+                        } | {
+                            id: string;
+                            url: string;
+                            label: string;
+                            line: string;
+                            owner: string;
+                            state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                            retention: "preview" | "published";
+                            createdAt: string;
+                            lastCallAt?: string | undefined;
+                            expiresAt?: string | undefined;
+                            retiredAt?: string | undefined;
+                            retirement?: "expired" | "withdrawn" | undefined;
+                            signingKeyId: string;
+                            record: unknown;
+                        })[];
+                    };
+                }, "authenticated", true, false, undefined>>;
+                setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    name: string;
+                    value: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        name: string;
+                    } | {
+                        kind: "rejected";
+                        reason: "secret-undeclared" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, false, undefined>>;
+                secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: string[];
+                }, "authenticated", false, false, undefined>>;
+                lastCalls: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    labels: string[];
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, string | null>;
+                }, "authenticated", true, false, undefined>>;
+                expirePreviews: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    limit?: number | undefined;
+                    apply?: boolean | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        planned: string[];
+                        retired: string[];
+                        pending: string[];
+                    };
+                }, "authenticated", true, false, undefined>>;
+                retain: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    label: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        retention: "published";
+                    };
+                }, "authenticated", true, false, undefined>>;
+                retire: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        kind: "retired";
+                    } | {
+                        kind: "retiring";
+                        retryAfterMs: number;
+                    } | {
+                        kind: "rejected";
+                        reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                        message: string;
+                        retryAfter?: string | undefined;
+                    };
+                }, "authenticated", false, false, undefined>>;
+            };
+            readonly policies: {
+                read: () => import("@astrale-os/sdk/schema").Policy;
+            };
+        }>;
+        readonly line_owned_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "line";
+                readonly outgoing: "0..1";
+            };
+            readonly target: {
+                readonly as: "owner";
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+        readonly deployment_on_line: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "deployment";
+                readonly outgoing: "1";
+            };
+            readonly target: {
+                readonly as: "line";
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
     };
     readonly policies: {
         readonly OwnService: import("@astrale-os/sdk/schema").Policy;
         readonly TraverseOwnedService: import("@astrale-os/sdk/schema").Policy;
+        readonly OwnLine: import("@astrale-os/sdk/schema").Policy;
+        readonly OwnDeployment: import("@astrale-os/sdk/schema").Policy;
+        readonly ActForOrganization: import("@astrale-os/sdk/schema").Policy;
+        readonly TraverseOwnedLine: import("@astrale-os/sdk/schema").Policy;
+        readonly TraverseOwnedLineDeployment: import("@astrale-os/sdk/schema").Policy;
     };
     readonly views: {
         readonly application: import("@astrale-os/sdk/schema").View;