@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/operator-contracts/seed/seed-bundle.d.ts

@@ -0,0 +1,138 @@
+import type { ProviderLanePurpose } from '../../agent-capacity/contracts/capacity/communication/communication-records.js';
+export declare const SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v3";
+export declare const HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION: "treeseed.seed-bundle/v2";
+export type SeedEnvironment = 'local' | 'staging' | 'prod' | string;
+export interface SeedTeamResource {
+    key: string;
+    slug: string;
+    name: string;
+    displayName: string;
+    profileSummary?: string;
+}
+export interface SeedUserMembershipResource {
+    key: string;
+    team: string;
+    principal: {
+        kind: 'user';
+        email: string;
+    };
+    roles: string[];
+    missingUser: 'defer' | 'reject';
+}
+export interface SeedServicePrincipalMembershipResource {
+    key: string;
+    team: string;
+    principal: {
+        kind: 'service-principal';
+        key: string;
+        displayName: string;
+        interactiveLogin: false;
+    };
+    roles: string[];
+}
+export type SeedMembershipResource = SeedUserMembershipResource | SeedServicePrincipalMembershipResource;
+export interface SeedRepositoryPolicy {
+    visibility: 'public' | 'private';
+    lifecycle: 'adopt' | 'create-or-adopt';
+    deletionPolicy: 'retain';
+    defaultBranch: string;
+    stagingBranch: string;
+    issues: boolean;
+    actions: boolean;
+    workflows: string[];
+}
+export interface SeedRepositoryResource {
+    key: string;
+    project: string;
+    role: 'primary' | 'library' | 'fixture' | 'support' | 'template';
+    provider: 'github';
+    owner: string;
+    name: string;
+    gitUrl: string;
+    defaultBranch: string;
+    checkoutPath?: string;
+    submodulePath?: string;
+    repositoryPolicy: SeedRepositoryPolicy;
+    metadata?: Record<string, unknown>;
+}
+export interface SeedProjectResource {
+    key: string;
+    team: string;
+    slug: string;
+    name: string;
+    description: string;
+    kind: string;
+    primaryRepository?: string;
+    libraryRepository: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SeedCapacityProviderPrerequisite {
+    key: string;
+    team: string;
+    environments: SeedEnvironment[];
+    manifestDigest: `sha256:${string}`;
+    manifestRef: string;
+    approval: 'trusted-local-owner';
+    projects: string[];
+    allowedModes: Array<'planning' | 'acting'>;
+    requiredLanePurposes: ProviderLanePurpose[];
+}
+interface SeedBundleBody {
+    name: string;
+    version: number;
+    description: string;
+    environments: SeedEnvironment[];
+    digest: `sha256:${string}`;
+    resources: {
+        teams: SeedTeamResource[];
+        memberships: SeedMembershipResource[];
+        projects: SeedProjectResource[];
+        repositories: SeedRepositoryResource[];
+    };
+    runtime: {
+        capacityProviders: SeedCapacityProviderPrerequisite[];
+    };
+}
+export interface SeedBundleV3 extends SeedBundleBody {
+    schemaVersion: typeof SEED_BUNDLE_SCHEMA_VERSION;
+}
+/** Historical receipt shape. It is decodable, but cannot be planned or applied. */
+export interface SeedBundleV2 extends Omit<SeedBundleBody, 'resources'> {
+    schemaVersion: typeof HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION;
+    resources: Omit<SeedBundleBody['resources'], 'projects'> & {
+        projects: Array<Omit<SeedProjectResource, 'libraryRepository'> & {
+            libraryRepository?: string;
+        }>;
+    };
+}
+export type SeedBundle = SeedBundleV3 | SeedBundleV2;
+export interface SeedResourceReceipt {
+    resourceKey: string;
+    action: 'create' | 'adopt' | 'update' | 'noop' | 'blocked';
+    resourceId?: string;
+    digest: `sha256:${string}`;
+    readBackAt?: string;
+    blockers?: string[];
+}
+export interface SeedReconciliationReceipt {
+    schemaVersion: 'treeseed.seed-reconciliation-receipt/v1';
+    runId: string;
+    seedName: string;
+    seedVersion: number;
+    seedDigest: `sha256:${string}`;
+    mode: 'plan' | 'apply' | 'verify';
+    status: 'planned' | 'waiting_provider' | 'verified' | 'blocked' | 'failed';
+    resources: SeedResourceReceipt[];
+    providerRequestIds: string[];
+    createdAt: string;
+    completedAt?: string;
+}
+export interface SeedBundleDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function canonicalSeedBundlePayload(bundle: Omit<SeedBundle, 'digest'> | SeedBundle): string;
+export declare function digestSeedBundle(bundle: Omit<SeedBundle, 'digest'> | SeedBundle): Promise<`sha256:${string}`>;
+export declare function validateSeedBundle(bundle: SeedBundle): SeedBundleDiagnostic[];
+export {};

package/dist/operator-contracts/seed/seed-bundle.js

@@ -0,0 +1,68 @@
+const SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v3";
+const HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION = "treeseed.seed-bundle/v2";
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonical(entry)]));
+}
+function canonicalSeedBundlePayload(bundle) {
+  const { digest: _digest, ...payload } = bundle;
+  return JSON.stringify(canonical(payload));
+}
+async function digestSeedBundle(bundle) {
+  const bytes = new TextEncoder().encode(canonicalSeedBundlePayload(bundle));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return `sha256:${Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("")}`;
+}
+function validateSeedBundle(bundle) {
+  const diagnostics = [];
+  const add = (code, path, message) => diagnostics.push({ code, path, message });
+  if (bundle?.schemaVersion === HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION) {
+    add("seed_bundle_v2_migration_required", "schemaVersion", `Historical v2 bundles remain readable but must be migrated to ${SEED_BUNDLE_SCHEMA_VERSION} before planning or apply.`);
+  } else if (bundle?.schemaVersion !== SEED_BUNDLE_SCHEMA_VERSION) {
+    add("seed_bundle_schema_invalid", "schemaVersion", `schemaVersion must be ${SEED_BUNDLE_SCHEMA_VERSION}.`);
+  }
+  if (!text(bundle?.name) || !Number.isInteger(bundle?.version) || bundle.version < 1) add("seed_bundle_identity_invalid", "name", "Seed name and positive version are required.");
+  if (!/^sha256:[a-f0-9]{64}$/u.test(bundle?.digest ?? "")) add("seed_bundle_digest_invalid", "digest", "Seed digest must be an exact SHA-256 digest.");
+  const teams = new Set((bundle?.resources?.teams ?? []).map((entry) => entry.key));
+  const projects = new Set((bundle?.resources?.projects ?? []).map((entry) => entry.key));
+  const repositories = new Set((bundle?.resources?.repositories ?? []).map((entry) => entry.key));
+  const allKeys = [...teams, ...projects, ...repositories, ...(bundle?.resources?.memberships ?? []).map((entry) => entry.key)];
+  if (new Set(allKeys).size !== allKeys.length) add("seed_bundle_resource_key_duplicate", "resources", "Every resource key must be globally unique.");
+  for (const [index, membership] of (bundle?.resources?.memberships ?? []).entries()) {
+    if (!teams.has(membership.team)) add("seed_bundle_membership_team_unknown", `resources.memberships[${index}].team`, "Membership references an unknown team.");
+    if (membership.principal.kind === "service-principal" && membership.principal.interactiveLogin !== false) add("seed_bundle_service_principal_interactive_forbidden", `resources.memberships[${index}].principal.interactiveLogin`, "Service principals cannot log in interactively.");
+  }
+  for (const [index, project] of (bundle?.resources?.projects ?? []).entries()) {
+    if (!teams.has(project.team)) add("seed_bundle_project_team_unknown", `resources.projects[${index}].team`, "Project references an unknown team.");
+    if (!project.primaryRepository && project.kind !== "content") add("seed_bundle_primary_repository_required", `resources.projects[${index}].primaryRepository`, "Non-content projects require a primary source repository.");
+    if (project.primaryRepository && !repositories.has(project.primaryRepository)) add("seed_bundle_primary_repository_unknown", `resources.projects[${index}].primaryRepository`, "Project primary repository is missing.");
+    if (!project.libraryRepository) add("seed_bundle_library_repository_required", `resources.projects[${index}].libraryRepository`, "Every project requires one library repository.");
+    if (project.libraryRepository && !repositories.has(project.libraryRepository)) add("seed_bundle_library_repository_unknown", `resources.projects[${index}].libraryRepository`, "Project library repository is missing.");
+  }
+  for (const [index, repository] of (bundle?.resources?.repositories ?? []).entries()) {
+    if (repository.role === "content") add("seed_bundle_content_repository_renamed", `resources.repositories[${index}].role`, "Repository-backed knowledge uses role library.");
+  }
+  for (const [index, project] of (bundle?.resources?.projects ?? []).entries()) {
+    const library = (bundle?.resources?.repositories ?? []).find((entry) => entry.key === project.libraryRepository);
+    if (library && (library.role !== "library" || library.project !== project.key)) add("seed_bundle_library_repository_mismatch", `resources.projects[${index}].libraryRepository`, "libraryRepository must reference a library-role repository owned by this project.");
+    const projectLibraries = (bundle?.resources?.repositories ?? []).filter((entry) => entry.project === project.key && entry.role === "library");
+    if (projectLibraries.length !== 1) add("seed_bundle_library_repository_count_invalid", `resources.projects[${index}].libraryRepository`, "Every project must declare exactly one library-role repository.");
+  }
+  for (const [index, provider] of (bundle?.runtime?.capacityProviders ?? []).entries()) {
+    if (!teams.has(provider.team)) add("seed_bundle_provider_team_unknown", `runtime.capacityProviders[${index}].team`, "Provider references an unknown team.");
+    for (const project of provider.projects) if (!projects.has(project)) add("seed_bundle_provider_project_unknown", `runtime.capacityProviders[${index}].projects`, `Provider references unknown project ${project}.`);
+    for (const purpose of ["communication", "platform", "workday"]) if (!provider.requiredLanePurposes.includes(purpose)) add("seed_bundle_provider_lane_required", `runtime.capacityProviders[${index}].requiredLanePurposes`, `Provider prerequisite requires the ${purpose} lane.`);
+  }
+  return diagnostics;
+}
+export {
+  HISTORICAL_SEED_BUNDLE_SCHEMA_VERSION,
+  SEED_BUNDLE_SCHEMA_VERSION,
+  canonicalSeedBundlePayload,
+  digestSeedBundle,
+  validateSeedBundle
+};

package/dist/platform/contracts.d.ts

@@ -0,0 +1,429 @@
+import { z } from 'zod';
+export declare const integrationComponentSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    commit: z.ZodString;
+    digest: z.ZodString;
+    artifact: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    version: string;
+    commit: string;
+    digest: string;
+    artifact: string;
+}, {
+    id: string;
+    version: string;
+    commit: string;
+    digest: string;
+    artifact: string;
+}>;
+export declare const integrationLockSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.platform-integration-lock/v1">;
+    release: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        commit: z.ZodString;
+        digest: z.ZodString;
+        artifact: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        commit: string;
+        digest: string;
+        artifact: string;
+    }, {
+        id: string;
+        version: string;
+        commit: string;
+        digest: string;
+        artifact: string;
+    }>, "many">;
+    digest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.platform-integration-lock/v1";
+    digest: string;
+    release: string;
+    components: {
+        id: string;
+        version: string;
+        commit: string;
+        digest: string;
+        artifact: string;
+    }[];
+}, {
+    schemaVersion: "treeseed.platform-integration-lock/v1";
+    digest: string;
+    release: string;
+    components: {
+        id: string;
+        version: string;
+        commit: string;
+        digest: string;
+        artifact: string;
+    }[];
+}>;
+export declare const hostTemplateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.platform-host-template/v1">;
+    id: z.ZodString;
+    profiles: z.ZodArray<z.ZodString, "many">;
+    integration: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        digest: string;
+    }, {
+        id: string;
+        digest: string;
+    }>;
+    inputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        sensitive: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+    }, {
+        name: string;
+        required: boolean;
+        sensitive?: boolean | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    schemaVersion: "treeseed.platform-host-template/v1";
+    profiles: string[];
+    integration: {
+        id: string;
+        digest: string;
+    };
+    inputs: {
+        name: string;
+        required: boolean;
+        sensitive: boolean;
+    }[];
+}, {
+    id: string;
+    schemaVersion: "treeseed.platform-host-template/v1";
+    profiles: string[];
+    integration: {
+        id: string;
+        digest: string;
+    };
+    inputs: {
+        name: string;
+        required: boolean;
+        sensitive?: boolean | undefined;
+    }[];
+}>;
+export declare const projectCreatePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.platform-project-create-plan/v1">;
+    slug: z.ZodString;
+    template: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        digest: string;
+    }, {
+        id: string;
+        version: string;
+        digest: string;
+    }>;
+    team: z.ZodString;
+    repository: z.ZodObject<{
+        owner: z.ZodString;
+        name: z.ZodString;
+        visibility: z.ZodEnum<["public", "private"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    }, {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    }>;
+    steps: z.ZodArray<z.ZodEnum<["project", "repository", "template", "library", "inventory"]>, "many">;
+    actions: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<["project", "repository", "template", "library", "inventory"]>;
+        action: z.ZodEnum<["create", "adopt", "apply", "bind", "publish", "noop", "blocked"]>;
+    }, "strip", z.ZodTypeAny, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }>, "many">;
+    observationDigest: z.ZodString;
+    planDigest: z.ZodString;
+    ok: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.platform-project-create-plan/v1";
+    slug: string;
+    repository: {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    };
+    blockers: string[];
+    ok: boolean;
+    planDigest: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    observationDigest: string;
+}, {
+    schemaVersion: "treeseed.platform-project-create-plan/v1";
+    slug: string;
+    repository: {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    };
+    blockers: string[];
+    ok: boolean;
+    planDigest: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    steps: ("project" | "library" | "repository" | "template" | "inventory")[];
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    observationDigest: string;
+}>;
+export declare const projectCreateReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.platform-project-create-receipt/v1">;
+    planDigest: z.ZodString;
+    slug: z.ZodString;
+    template: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        digest: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        digest: string;
+    }, {
+        id: string;
+        version: string;
+        digest: string;
+    }>;
+    team: z.ZodString;
+    repository: z.ZodObject<{
+        owner: z.ZodString;
+        name: z.ZodString;
+        visibility: z.ZodEnum<["public", "private"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    }, {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    }>;
+    projectId: z.ZodString;
+    repositoryUrl: z.ZodString;
+    libraryBindingId: z.ZodString;
+    inventoryVersion: z.ZodNumber;
+    actions: z.ZodArray<z.ZodObject<{
+        step: z.ZodEnum<["project", "repository", "template", "library", "inventory"]>;
+        action: z.ZodEnum<["create", "adopt", "apply", "bind", "publish", "noop", "blocked"]>;
+    }, "strip", z.ZodTypeAny, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }, {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.platform-project-create-receipt/v1";
+    slug: string;
+    repository: {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    };
+    planDigest: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    projectId: string;
+    repositoryUrl: string;
+    libraryBindingId: string;
+    inventoryVersion: number;
+}, {
+    schemaVersion: "treeseed.platform-project-create-receipt/v1";
+    slug: string;
+    repository: {
+        name: string;
+        owner: string;
+        visibility: "public" | "private";
+    };
+    planDigest: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    actions: {
+        action: "noop" | "blocked" | "create" | "adopt" | "apply" | "bind" | "publish";
+        step: "project" | "library" | "repository" | "template" | "inventory";
+    }[];
+    projectId: string;
+    repositoryUrl: string;
+    libraryBindingId: string;
+    inventoryVersion: number;
+}>;
+export declare const providerRegistrationRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-registration-request/v1">;
+    requestId: z.ZodString;
+    teamId: z.ZodString;
+    publicKey: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString, "many">;
+    state: z.ZodEnum<["pending-approval", "approved", "rejected", "revoked"]>;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    state: "pending-approval" | "approved" | "rejected" | "revoked";
+    schemaVersion: "treeseed.provider-registration-request/v1";
+    requestId: string;
+    teamId: string;
+    publicKey: string;
+    capabilities: string[];
+    createdAt: string;
+}, {
+    state: "pending-approval" | "approved" | "rejected" | "revoked";
+    schemaVersion: "treeseed.provider-registration-request/v1";
+    requestId: string;
+    teamId: string;
+    publicKey: string;
+    capabilities: string[];
+    createdAt: string;
+}>;
+export declare const providerSessionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-session/v1">;
+    providerId: z.ZodString;
+    scope: z.ZodArray<z.ZodString, "many">;
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodString;
+    token: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    expiresAt: string;
+    schemaVersion: "treeseed.provider-session/v1";
+    providerId: string;
+    scope: string[];
+    issuedAt: string;
+    token: string;
+}, {
+    expiresAt: string;
+    schemaVersion: "treeseed.provider-session/v1";
+    providerId: string;
+    scope: string[];
+    issuedAt: string;
+    token: string;
+}>;
+export declare const environmentProfileDescriptorSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.provider-environment-profile/v1">;
+    id: z.ZodString;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        available: z.ZodBoolean;
+        rotatedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        available: boolean;
+        rotatedAt?: string | undefined;
+    }, {
+        name: string;
+        available: boolean;
+        rotatedAt?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    schemaVersion: "treeseed.provider-environment-profile/v1";
+    variables: {
+        name: string;
+        available: boolean;
+        rotatedAt?: string | undefined;
+    }[];
+}, {
+    id: string;
+    schemaVersion: "treeseed.provider-environment-profile/v1";
+    variables: {
+        name: string;
+        available: boolean;
+        rotatedAt?: string | undefined;
+    }[];
+}>;
+export declare const assignmentEnvironmentGrantSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.assignment-environment-grant/v1">;
+    assignmentId: z.ZodString;
+    profileId: z.ZodString;
+    variables: z.ZodArray<z.ZodString, "many">;
+    network: z.ZodObject<{
+        allowed: z.ZodBoolean;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        allowed: boolean;
+        destinations: string[];
+    }, {
+        allowed: boolean;
+        destinations?: string[] | undefined;
+    }>;
+    expiresAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    expiresAt: string;
+    schemaVersion: "treeseed.assignment-environment-grant/v1";
+    variables: string[];
+    assignmentId: string;
+    profileId: string;
+    network: {
+        allowed: boolean;
+        destinations: string[];
+    };
+}, {
+    expiresAt: string;
+    schemaVersion: "treeseed.assignment-environment-grant/v1";
+    variables: string[];
+    assignmentId: string;
+    profileId: string;
+    network: {
+        allowed: boolean;
+        destinations?: string[] | undefined;
+    };
+}>;
+export type IntegrationLock = z.infer<typeof integrationLockSchema>;
+export type HostTemplate = z.infer<typeof hostTemplateSchema>;
+export type ProjectCreatePlan = z.infer<typeof projectCreatePlanSchema>;
+export type ProjectCreateReceipt = z.infer<typeof projectCreateReceiptSchema>;
+export type ProviderRegistrationRequest = z.infer<typeof providerRegistrationRequestSchema>;
+export type ProviderSession = z.infer<typeof providerSessionSchema>;
+export type EnvironmentProfileDescriptor = z.infer<typeof environmentProfileDescriptorSchema>;
+export type AssignmentEnvironmentGrant = z.infer<typeof assignmentEnvironmentGrantSchema>;