@treeseed/sdk 0.13.0-rc.12 → 0.13.0-rc.121

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>;

package/dist/platform/contracts.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+const digest = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const commit = z.string().regex(/^[0-9a-f]{40}$/u);
+const integrationComponentSchema = z.object({
+  id: z.string().min(1),
+  version: z.string().min(1),
+  commit,
+  digest,
+  artifact: z.string().min(1)
+}).strict();
+const integrationLockSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-integration-lock/v1"),
+  release: z.string().min(1),
+  components: z.array(integrationComponentSchema).min(1),
+  digest
+}).strict();
+const hostTemplateSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-host-template/v1"),
+  id: z.string().min(1),
+  profiles: z.array(z.string().min(1)).min(1),
+  integration: z.object({ id: z.string().min(1), digest }),
+  inputs: z.array(z.object({ name: z.string().min(1), required: z.boolean(), sensitive: z.boolean().default(false) }))
+}).strict();
+const projectCreatePlanSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-project-create-plan/v1"),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+  template: z.object({ id: z.string().min(1), version: z.string().min(1), digest }),
+  team: z.string().min(1),
+  repository: z.object({ owner: z.string().min(1), name: z.string().min(1), visibility: z.enum(["public", "private"]) }),
+  steps: z.array(z.enum(["project", "repository", "template", "library", "inventory"])),
+  actions: z.array(z.object({
+    step: z.enum(["project", "repository", "template", "library", "inventory"]),
+    action: z.enum(["create", "adopt", "apply", "bind", "publish", "noop", "blocked"])
+  })),
+  observationDigest: digest,
+  planDigest: digest,
+  ok: z.boolean(),
+  blockers: z.array(z.string())
+}).strict();
+const projectCreateReceiptSchema = z.object({
+  schemaVersion: z.literal("treeseed.platform-project-create-receipt/v1"),
+  planDigest: digest,
+  slug: projectCreatePlanSchema.shape.slug,
+  template: projectCreatePlanSchema.shape.template,
+  team: z.string().min(1),
+  repository: projectCreatePlanSchema.shape.repository,
+  projectId: z.string().min(1),
+  repositoryUrl: z.string().url(),
+  libraryBindingId: z.string().min(1),
+  inventoryVersion: z.number().int().positive(),
+  actions: projectCreatePlanSchema.shape.actions
+}).strict();
+const providerRegistrationRequestSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-registration-request/v1"),
+  requestId: z.string().uuid(),
+  teamId: z.string().min(1),
+  publicKey: z.string().min(32),
+  capabilities: z.array(z.string().min(1)),
+  state: z.enum(["pending-approval", "approved", "rejected", "revoked"]),
+  createdAt: z.string().datetime()
+}).strict();
+const providerSessionSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-session/v1"),
+  providerId: z.string().min(1),
+  scope: z.array(z.string().min(1)).min(1),
+  issuedAt: z.string().datetime(),
+  expiresAt: z.string().datetime(),
+  token: z.string().min(1)
+}).strict();
+const environmentProfileDescriptorSchema = z.object({
+  schemaVersion: z.literal("treeseed.provider-environment-profile/v1"),
+  id: z.string().min(1),
+  variables: z.array(z.object({ name: z.string().regex(/^[A-Z_][A-Z0-9_]*$/u), available: z.boolean(), rotatedAt: z.string().datetime().optional() }))
+}).strict();
+const assignmentEnvironmentGrantSchema = z.object({
+  schemaVersion: z.literal("treeseed.assignment-environment-grant/v1"),
+  assignmentId: z.string().min(1),
+  profileId: z.string().min(1),
+  variables: z.array(z.string().regex(/^[A-Z_][A-Z0-9_]*$/u)),
+  network: z.object({ allowed: z.boolean(), destinations: z.array(z.string()).default([]) }),
+  expiresAt: z.string().datetime()
+}).strict();
+export {
+  assignmentEnvironmentGrantSchema,
+  environmentProfileDescriptorSchema,
+  hostTemplateSchema,
+  integrationComponentSchema,
+  integrationLockSchema,
+  projectCreatePlanSchema,
+  projectCreateReceiptSchema,
+  providerRegistrationRequestSchema,
+  providerSessionSchema
+};

package/dist/platform/index.d.ts

@@ -0,0 +1,6 @@
+export * from './schemas.js';
+export * from './contracts.js';
+export * from './inventory.js';
+export * from './project-create.js';
+export * from './workset.js';
+export * from './verification.js';

package/dist/platform/index.js

@@ -0,0 +1,6 @@
+export * from "./schemas.js";
+export * from "./contracts.js";
+export * from "./inventory.js";
+export * from "./project-create.js";
+export * from "./workset.js";
+export * from "./verification.js";

package/dist/platform/inventory.d.ts

@@ -0,0 +1,11 @@
+import { type Inventory, type PlatformProfile } from './schemas.js';
+export interface LoadedInventory {
+    root: string;
+    path: string;
+    digest: string;
+    inventory: Inventory;
+}
+export declare function loadPlatformInventory(root?: string): LoadedInventory;
+export declare function loadPlatformProfile(path: string): PlatformProfile;
+export declare function loadPlatformProfiles(root?: string): PlatformProfile[];
+export declare function resolveProfileProjects(profiles: readonly PlatformProfile[], selected: readonly string[]): string[];

package/dist/platform/inventory.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { parse } from "yaml";
+import { inventorySchema, profileSchema } from "./schemas.js";
+function yamlFile(path) {
+  return parse(readFileSync(path, "utf8"));
+}
+function loadPlatformInventory(root = process.cwd()) {
+  const sitePath = resolve(root, "treeseed.site.yaml");
+  const site = yamlFile(sitePath);
+  const reference = site.development?.local?.inventory;
+  if (reference?.source !== "seed" || !reference.path) {
+    throw new Error("treeseed.site.yaml must declare development.local.inventory with source seed and a relative path.");
+  }
+  if (resolve(root, reference.path) !== resolve(dirname(sitePath), reference.path)) {
+    throw new Error("Inventory path must resolve beneath the Platform root.");
+  }
+  const path = resolve(root, reference.path);
+  if (!path.startsWith(`${resolve(root)}/`)) throw new Error("Inventory path escapes the Platform root.");
+  const source = readFileSync(path, "utf8");
+  return { root: resolve(root), path, digest: `sha256:${createHash("sha256").update(source).digest("hex")}`, inventory: inventorySchema.parse(parse(source)) };
+}
+function loadPlatformProfile(path) {
+  return profileSchema.parse(yamlFile(path));
+}
+function loadPlatformProfiles(root = process.cwd()) {
+  const directory = resolve(root, "profiles");
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.ya?ml$/u.test(entry.name)).map((entry) => loadPlatformProfile(resolve(directory, entry.name))).sort((left, right) => left.id.localeCompare(right.id));
+}
+function resolveProfileProjects(profiles, selected) {
+  const catalog = new Map(profiles.map((profile) => [profile.id, profile]));
+  const result = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (active.has(id)) throw new Error(`Profile inheritance cycle includes ${id}.`);
+    const profile = catalog.get(id);
+    if (!profile) throw new Error(`Unknown Platform profile ${id}.`);
+    active.add(id);
+    profile.extends.forEach(visit);
+    profile.sources.projects.forEach((project) => result.add(project));
+    active.delete(id);
+  };
+  selected.forEach(visit);
+  return [...result].sort();
+}
+export {
+  loadPlatformInventory,
+  loadPlatformProfile,
+  loadPlatformProfiles,
+  resolveProfileProjects
+};

package/dist/platform/project-create.d.ts

@@ -0,0 +1,49 @@
+import { type ProjectCreatePlan, type ProjectCreateReceipt } from './contracts.js';
+export type ProjectCreateStep = 'project' | 'repository' | 'template' | 'library' | 'inventory';
+export type ProjectCreateState = 'missing' | 'ready' | 'conflict';
+export interface ProjectCreateTarget {
+    slug: string;
+    template: {
+        id: string;
+        version: string;
+        digest: string;
+    };
+    team: string;
+    repository: {
+        owner: string;
+        name: string;
+        visibility: 'public' | 'private';
+    };
+}
+export interface ProjectCreateObservation {
+    project: {
+        state: ProjectCreateState;
+        id?: string;
+    };
+    repository: {
+        state: ProjectCreateState;
+        url?: string;
+    };
+    template: {
+        state: ProjectCreateState;
+        digest?: string;
+    };
+    library: {
+        state: ProjectCreateState;
+        bindingId?: string;
+    };
+    inventory: {
+        state: ProjectCreateState;
+        version?: number;
+    };
+}
+export interface ProjectCreateAuthority {
+    observe(target: ProjectCreateTarget): Promise<ProjectCreateObservation>;
+    reconcileProject(target: ProjectCreateTarget): Promise<void>;
+    reconcileRepository(target: ProjectCreateTarget): Promise<void>;
+    applyTemplate(target: ProjectCreateTarget): Promise<void>;
+    reconcileLibrary(target: ProjectCreateTarget): Promise<void>;
+    publishInventory(target: ProjectCreateTarget): Promise<void>;
+}
+export declare function planPlatformProjectCreate(target: ProjectCreateTarget, authority: Pick<ProjectCreateAuthority, 'observe'>): Promise<ProjectCreatePlan>;
+export declare function applyPlatformProjectCreate(plan: ProjectCreatePlan, authority: ProjectCreateAuthority): Promise<ProjectCreateReceipt>;