@dork-labs/cloud-api 0.76.0 → 0.82.0

package/dist/communities.d.ts

@@ -0,0 +1,706 @@
+import { z } from 'zod';
+/**
+ * The grammar every community short name obeys.
+ *
+ * A short name is the optional address alias a Community server gives a
+ * community beside its permanent identifier. The grammar is the Community
+ * server's own: lower-case ASCII letters, digits and single hyphens, starting
+ * with a letter and not ending with a hyphen. Published so the app can refuse a
+ * bad name before a request goes out. Whether a well-formed name is free, or
+ * reserved by the host, only the service can say
+ * ({@link CommunityNameCheckResponseSchema}).
+ *
+ * Lower case by grammar, like `HandleSchema`: the app folds what a person
+ * types before sending it, and the service refuses a mixed-case name rather
+ * than folding it silently.
+ */
+export declare const CommunityShortNameSchema: z.ZodString;
+/**
+ * Where a hosted community is in its lifecycle.
+ *
+ * Mechanism: the Community server's own lifecycle names, plus `provisioning`
+ * for the moment between the service accepting a start and the server
+ * confirming it. A community a person has not yet claimed is `pending_owner`.
+ * A community that no longer exists does not appear at all.
+ */
+export declare const HostedCommunityStateSchema: z.ZodEnum<{
+    active: "active";
+    provisioning: "provisioning";
+    pending_owner: "pending_owner";
+    archived: "archived";
+    held: "held";
+    suspended: "suspended";
+    deletion_pending: "deletion_pending";
+}>;
+/** Where a hosted community is in its lifecycle. */
+export type HostedCommunityState = z.infer<typeof HostedCommunityStateSchema>;
+/**
+ * Why a hosted community is on hold.
+ *
+ * A hold makes a community read-only: people can read it and its owner can
+ * export it, and nothing new can be written. The reason tells the app which
+ * way out to offer.
+ *
+ * - `over_limit`: the account holds more than its allowance covers. Choosing
+ *   which communities to keep, or a larger allowance, lifts it.
+ * - `inactive`: the service paused a community nobody has posted in for a long
+ *   time. Restoring it lifts it, when it fits the account's allowance.
+ * - `host`: the host placed the hold for its own reasons. The owner cannot lift
+ *   it from the app; the community's `notice` says who to contact.
+ */
+export declare const HostedCommunityHoldReasonSchema: z.ZodEnum<{
+    inactive: "inactive";
+    over_limit: "over_limit";
+    host: "host";
+}>;
+/** Why a hosted community is on hold. */
+export type HostedCommunityHoldReason = z.infer<typeof HostedCommunityHoldReasonSchema>;
+/**
+ * What the service wants the owner to read about a community, in its own words.
+ *
+ * The app shows `title` and `detail` as given and, when present, a button that
+ * opens `actionUrl`. It is how a host hold, a suspension or a planned deletion
+ * is explained honestly without this contract enumerating every reason a host
+ * might have. A malformed link or label is dropped, like the one on `Problem`,
+ * so a bad link never costs the owner the notice itself.
+ */
+export declare const HostedCommunityNoticeSchema: z.ZodObject<{
+    title: z.ZodString;
+    detail: z.ZodString;
+    actionUrl: z.ZodCatch<z.ZodOptional<z.ZodURL>>;
+    actionLabel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Whether the owner may keep this community open, and what that would cost.
+ *
+ * `wouldHold` is the preview the app shows before the owner confirms: keeping
+ * this community can put others on hold. The keep request echoes it back as
+ * `expectedHeldCommunityIds`, so a choice made against a stale preview is
+ * refused rather than holding a community nobody was warned about.
+ */
+export declare const HostedCommunityKeepActionSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    wouldHold: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * One community the caller has hosted.
+ *
+ * `limits` and `usage` are numbers, never a plan: the app says "this community
+ * is full" from them without knowing what the caller bought. `actions` is the
+ * service's answer to "what may this person do next", so the app renders a
+ * button only when the service will accept it and never re-derives the rule.
+ * A new action arrives as a new optional field of `actions`.
+ *
+ * A `held` community always says why (`hold`), and one in `deletion_pending`
+ * always says when (`deletionAt`). The rules run one way only: a later release
+ * may carry a hold into another state (a held community whose deletion has
+ * started, for instance), and that must still parse.
+ *
+ * `state` and `hold.reason` are tolerant: a value added in a later release
+ * reads as `unrecognised` rather than failing the page it arrives in.
+ */
+export declare const HostedCommunitySchema: z.ZodObject<{
+    communityId: z.ZodString;
+    orgId: z.ZodString;
+    name: z.ZodString;
+    shortName: z.ZodNullable<z.ZodString>;
+    communityUrl: z.ZodURL;
+    state: z.ZodUnion<readonly [z.ZodEnum<{
+        active: "active";
+        provisioning: "provisioning";
+        pending_owner: "pending_owner";
+        archived: "archived";
+        held: "held";
+        suspended: "suspended";
+        deletion_pending: "deletion_pending";
+    }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+    hold: z.ZodNullable<z.ZodObject<{
+        reason: z.ZodUnion<readonly [z.ZodEnum<{
+            inactive: "inactive";
+            over_limit: "over_limit";
+            host: "host";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        since: z.ZodISODateTime;
+        deletionNoticeAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    deletionAt: z.ZodNullable<z.ZodISODateTime>;
+    notice: z.ZodNullable<z.ZodObject<{
+        title: z.ZodString;
+        detail: z.ZodString;
+        actionUrl: z.ZodCatch<z.ZodOptional<z.ZodURL>>;
+        actionLabel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    kept: z.ZodBoolean;
+    moveId: z.ZodNullable<z.ZodString>;
+    limits: z.ZodObject<{
+        maxActiveMembers: z.ZodNullable<z.ZodNumber>;
+        maxStorageBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    usage: z.ZodNullable<z.ZodObject<{
+        activeMembers: z.ZodNumber;
+        storageBytes: z.ZodNumber;
+        measuredAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    actions: z.ZodObject<{
+        claimLink: z.ZodBoolean;
+        keep: z.ZodObject<{
+            allowed: z.ZodBoolean;
+            wouldHold: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        restore: z.ZodBoolean;
+    }, z.core.$strip>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** One community the caller has hosted. */
+export type HostedCommunity = z.infer<typeof HostedCommunitySchema>;
+/**
+ * `GET /v1/communities` — the caller's hosted communities.
+ *
+ * Every community the caller owns or started, across every organization they
+ * belong to, in no particular order. The app reads it to show what the caller
+ * already has, to finish a claim or a move after a restart, and to offer the
+ * way out of a hold.
+ */
+export declare const HostedCommunityListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        communityId: z.ZodString;
+        orgId: z.ZodString;
+        name: z.ZodString;
+        shortName: z.ZodNullable<z.ZodString>;
+        communityUrl: z.ZodURL;
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            active: "active";
+            provisioning: "provisioning";
+            pending_owner: "pending_owner";
+            archived: "archived";
+            held: "held";
+            suspended: "suspended";
+            deletion_pending: "deletion_pending";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        hold: z.ZodNullable<z.ZodObject<{
+            reason: z.ZodUnion<readonly [z.ZodEnum<{
+                inactive: "inactive";
+                over_limit: "over_limit";
+                host: "host";
+            }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+            since: z.ZodISODateTime;
+            deletionNoticeAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        deletionAt: z.ZodNullable<z.ZodISODateTime>;
+        notice: z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            detail: z.ZodString;
+            actionUrl: z.ZodCatch<z.ZodOptional<z.ZodURL>>;
+            actionLabel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>;
+        kept: z.ZodBoolean;
+        moveId: z.ZodNullable<z.ZodString>;
+        limits: z.ZodObject<{
+            maxActiveMembers: z.ZodNullable<z.ZodNumber>;
+            maxStorageBytes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        usage: z.ZodNullable<z.ZodObject<{
+            activeMembers: z.ZodNumber;
+            storageBytes: z.ZodNumber;
+            measuredAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        actions: z.ZodObject<{
+            claimLink: z.ZodBoolean;
+            keep: z.ZodObject<{
+                allowed: z.ZodBoolean;
+                wouldHold: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            restore: z.ZodBoolean;
+        }, z.core.$strip>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** A page of the caller's hosted communities. */
+export type HostedCommunityListResponse = z.infer<typeof HostedCommunityListResponseSchema>;
+/** `GET /v1/communities/name-check` query parameters. */
+export declare const CommunityNameCheckQuerySchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Why a well-formed short name cannot be used.
+ *
+ * Mechanism, and the same two answers the start and move routes refuse with as
+ * `community_name_taken` and `community_name_reserved`. `taken` includes a name
+ * another community used recently and that is still held back.
+ */
+export declare const CommunityNameUnavailableReasonSchema: z.ZodEnum<{
+    taken: "taken";
+    reserved: "reserved";
+}>;
+/**
+ * `GET /v1/communities/name-check` — is this short name free right now?
+ *
+ * Advisory: it lets the start form say "That web address is taken" while a
+ * person types. The start and move routes check again and are the only answer
+ * that binds, so a name free here can still be refused a moment later.
+ * `reason` is null exactly when `available` is true.
+ */
+export declare const CommunityNameCheckResponseSchema: z.ZodObject<{
+    name: z.ZodString;
+    available: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodEnum<{
+        taken: "taken";
+        reserved: "reserved";
+    }>>;
+}, z.core.$strip>;
+/** Whether a short name is free right now. */
+export type CommunityNameCheckResponse = z.infer<typeof CommunityNameCheckResponseSchema>;
+/**
+ * `POST /v1/communities` — start a hosted community.
+ *
+ * Idempotent on `idempotencyKey`, scoped to the caller: the same key with the
+ * same body returns the same community (with `replayed: true`) rather than
+ * starting a second one, and the same key with a different body is refused
+ * with `conflict`. A refusal a larger allowance would lift is
+ * `entitlement_required`; a short name that cannot be used is
+ * `community_name_taken` or `community_name_reserved`.
+ */
+export declare const CommunityStartRequestSchema: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    name: z.ZodString;
+    shortName: z.ZodOptional<z.ZodString>;
+    orgId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Start a hosted community. */
+export type CommunityStartRequest = z.infer<typeof CommunityStartRequestSchema>;
+/**
+ * A one-time link that makes a person the owner of a new community.
+ *
+ * The link carries a single-use credential. Open it in the person's own
+ * browser, never log it, and never show it to anyone else. Issuing a fresh one
+ * revokes the last.
+ */
+export declare const CommunityClaimLinkSchema: z.ZodObject<{
+    communityId: z.ZodString;
+    claimUrl: z.ZodURL;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** A one-time owner-claim link. */
+export type CommunityClaimLink = z.infer<typeof CommunityClaimLinkSchema>;
+/**
+ * The started community.
+ *
+ * The first answer carries the claim link, and no later answer does: the link
+ * is a single-use credential and the service keeps no copy it could return
+ * again. `claim` is therefore null when `replayed` is true, and also while the
+ * community is still `provisioning` (the Community server has not confirmed
+ * it yet). In both cases the app waits for `pending_owner` in the list and
+ * asks `POST /v1/communities/{communityId}/claim-link` for a link.
+ */
+export declare const CommunityStartResponseSchema: z.ZodObject<{
+    community: z.ZodObject<{
+        communityId: z.ZodString;
+        orgId: z.ZodString;
+        name: z.ZodString;
+        shortName: z.ZodNullable<z.ZodString>;
+        communityUrl: z.ZodURL;
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            active: "active";
+            provisioning: "provisioning";
+            pending_owner: "pending_owner";
+            archived: "archived";
+            held: "held";
+            suspended: "suspended";
+            deletion_pending: "deletion_pending";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        hold: z.ZodNullable<z.ZodObject<{
+            reason: z.ZodUnion<readonly [z.ZodEnum<{
+                inactive: "inactive";
+                over_limit: "over_limit";
+                host: "host";
+            }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+            since: z.ZodISODateTime;
+            deletionNoticeAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        deletionAt: z.ZodNullable<z.ZodISODateTime>;
+        notice: z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            detail: z.ZodString;
+            actionUrl: z.ZodCatch<z.ZodOptional<z.ZodURL>>;
+            actionLabel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>;
+        kept: z.ZodBoolean;
+        moveId: z.ZodNullable<z.ZodString>;
+        limits: z.ZodObject<{
+            maxActiveMembers: z.ZodNullable<z.ZodNumber>;
+            maxStorageBytes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        usage: z.ZodNullable<z.ZodObject<{
+            activeMembers: z.ZodNumber;
+            storageBytes: z.ZodNumber;
+            measuredAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        actions: z.ZodObject<{
+            claimLink: z.ZodBoolean;
+            keep: z.ZodObject<{
+                allowed: z.ZodBoolean;
+                wouldHold: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            restore: z.ZodBoolean;
+        }, z.core.$strip>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    claim: z.ZodNullable<z.ZodObject<{
+        communityId: z.ZodString;
+        claimUrl: z.ZodURL;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+/** The started community. */
+export type CommunityStartResponse = z.infer<typeof CommunityStartResponseSchema>;
+/**
+ * `POST /v1/communities/{communityId}/keep` — the request.
+ *
+ * `expectedHeldCommunityIds` is the `actions.keep.wouldHold` preview the owner
+ * confirmed. When the service would now hold a different set, it refuses with
+ * `conflict` and holds nothing, so the app refreshes the list and asks again.
+ */
+export declare const CommunityKeepRequestSchema: z.ZodObject<{
+    expectedHeldCommunityIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** Keep this community open. */
+export type CommunityKeepRequest = z.infer<typeof CommunityKeepRequestSchema>;
+/**
+ * `POST /v1/communities/{communityId}/keep` — keep this community open.
+ *
+ * For an account that holds more communities than its allowance covers: the
+ * owner chooses which stay open. The answer names every other community the
+ * choice put on hold, which is exactly the confirmed preview. When no choice
+ * would make room, the refusal is `entitlement_required` with the service's
+ * own words and an `actionUrl`.
+ */
+export declare const CommunityKeepResponseSchema: z.ZodObject<{
+    community: z.ZodObject<{
+        communityId: z.ZodString;
+        orgId: z.ZodString;
+        name: z.ZodString;
+        shortName: z.ZodNullable<z.ZodString>;
+        communityUrl: z.ZodURL;
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            active: "active";
+            provisioning: "provisioning";
+            pending_owner: "pending_owner";
+            archived: "archived";
+            held: "held";
+            suspended: "suspended";
+            deletion_pending: "deletion_pending";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        hold: z.ZodNullable<z.ZodObject<{
+            reason: z.ZodUnion<readonly [z.ZodEnum<{
+                inactive: "inactive";
+                over_limit: "over_limit";
+                host: "host";
+            }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+            since: z.ZodISODateTime;
+            deletionNoticeAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        deletionAt: z.ZodNullable<z.ZodISODateTime>;
+        notice: z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            detail: z.ZodString;
+            actionUrl: z.ZodCatch<z.ZodOptional<z.ZodURL>>;
+            actionLabel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>;
+        kept: z.ZodBoolean;
+        moveId: z.ZodNullable<z.ZodString>;
+        limits: z.ZodObject<{
+            maxActiveMembers: z.ZodNullable<z.ZodNumber>;
+            maxStorageBytes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        usage: z.ZodNullable<z.ZodObject<{
+            activeMembers: z.ZodNumber;
+            storageBytes: z.ZodNumber;
+            measuredAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        actions: z.ZodObject<{
+            claimLink: z.ZodBoolean;
+            keep: z.ZodObject<{
+                allowed: z.ZodBoolean;
+                wouldHold: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            restore: z.ZodBoolean;
+        }, z.core.$strip>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    heldCommunityIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** The kept community, and every community the choice put on hold. */
+export type CommunityKeepResponse = z.infer<typeof CommunityKeepResponseSchema>;
+/**
+ * Where a move is.
+ *
+ * Mechanism: the stages of reading an owner export into a new community.
+ * `ready` means the history is in and the community waits for its owner to
+ * claim it; `claimed` means they have.
+ */
+export declare const CommunityMoveStateSchema: z.ZodEnum<{
+    awaiting_upload: "awaiting_upload";
+    importing: "importing";
+    ready: "ready";
+    failed: "failed";
+    cancelled: "cancelled";
+    claimed: "claimed";
+}>;
+/** Where a move is. */
+export type CommunityMoveState = z.infer<typeof CommunityMoveStateSchema>;
+/**
+ * Why a move failed, in terms a person can act on.
+ *
+ * Mechanism, one member per thing the app says differently:
+ *
+ * - `not_owner_export`: the file is a personal export, not the owner's.
+ * - `archive_invalid`: the file is damaged or not a community export at all.
+ * - `checksum_mismatch`: a file inside the export does not match the export's
+ *   own record of it, so the export itself is damaged. Export again.
+ * - `version_unsupported`: the export is from a version this host cannot read.
+ * - `too_large`: the export is larger than any single move may be.
+ * - `storage_limit_reached`: the files do not fit the community's storage limit.
+ * - `upload_expired`: the export did not arrive before the upload window closed.
+ * - `storage_unavailable`: the host could not store the files. Trying again later may work.
+ *
+ * An upload whose bytes do not match the declared size or digest is not a
+ * failure of the move: the upload is refused and the move stays
+ * `awaiting_upload` (see {@link CommunityMoveUploadSchema}). An upload window
+ * that closes before a matching file arrives is `upload_expired`.
+ */
+export declare const CommunityMoveFailureCodeSchema: z.ZodEnum<{
+    not_owner_export: "not_owner_export";
+    archive_invalid: "archive_invalid";
+    checksum_mismatch: "checksum_mismatch";
+    version_unsupported: "version_unsupported";
+    too_large: "too_large";
+    storage_limit_reached: "storage_limit_reached";
+    upload_expired: "upload_expired";
+    storage_unavailable: "storage_unavailable";
+}>;
+/** Why a move failed. */
+export type CommunityMoveFailureCode = z.infer<typeof CommunityMoveFailureCodeSchema>;
+/**
+ * What an owner export holds, measured before anything is restored.
+ *
+ * Counts and sizes only. No channel name, file name, person or text ever
+ * appears here.
+ */
+export declare const CommunityMoveReportSchema: z.ZodObject<{
+    channels: z.ZodNumber;
+    entries: z.ZodNumber;
+    attachments: z.ZodNumber;
+    historicalMembers: z.ZodNumber;
+    historicalAgents: z.ZodNumber;
+    attachmentBytes: z.ZodNumber;
+    countedBytes: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * One move of a community into hosting, from an owner export.
+ *
+ * A move fills a brand-new community. The old community is never touched and
+ * keeps running until its owner deletes it. Nothing of the new community is
+ * visible until the whole export is in. A failed or cancelled move removes the
+ * new community and everything uploaded for it, and frees its short name at
+ * once, so starting again with the same name works.
+ *
+ * A `failed` move always says why (`failureCode`); the rule runs one way only.
+ * `state` and `failureCode` are tolerant: a value added in a later release
+ * reads as `unrecognised` rather than failing the page it arrives in.
+ */
+export declare const CommunityMoveSchema: z.ZodObject<{
+    moveId: z.ZodString;
+    communityId: z.ZodString;
+    communityUrl: z.ZodURL;
+    name: z.ZodString;
+    state: z.ZodUnion<readonly [z.ZodEnum<{
+        awaiting_upload: "awaiting_upload";
+        importing: "importing";
+        ready: "ready";
+        failed: "failed";
+        cancelled: "cancelled";
+        claimed: "claimed";
+    }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+    failureCode: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+        not_owner_export: "not_owner_export";
+        archive_invalid: "archive_invalid";
+        checksum_mismatch: "checksum_mismatch";
+        version_unsupported: "version_unsupported";
+        too_large: "too_large";
+        storage_limit_reached: "storage_limit_reached";
+        upload_expired: "upload_expired";
+        storage_unavailable: "storage_unavailable";
+    }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>>;
+    report: z.ZodNullable<z.ZodObject<{
+        channels: z.ZodNumber;
+        entries: z.ZodNumber;
+        attachments: z.ZodNumber;
+        historicalMembers: z.ZodNumber;
+        historicalAgents: z.ZodNumber;
+        attachmentBytes: z.ZodNumber;
+        countedBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    pollAfterMs: z.ZodNullable<z.ZodNumber>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** One move of a community into hosting. */
+export type CommunityMove = z.infer<typeof CommunityMoveSchema>;
+/**
+ * `GET /v1/communities/moves` — the caller's moves.
+ *
+ * Every unfinished move, and every move that finished (failed, cancelled or
+ * claimed) within the last seven days, newest first. It is how the app shows
+ * a failed move to a person who closed the app while it was importing: the
+ * new community is gone by then, so the hosted-community list cannot.
+ */
+export declare const CommunityMoveListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        moveId: z.ZodString;
+        communityId: z.ZodString;
+        communityUrl: z.ZodURL;
+        name: z.ZodString;
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            awaiting_upload: "awaiting_upload";
+            importing: "importing";
+            ready: "ready";
+            failed: "failed";
+            cancelled: "cancelled";
+            claimed: "claimed";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        failureCode: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+            not_owner_export: "not_owner_export";
+            archive_invalid: "archive_invalid";
+            checksum_mismatch: "checksum_mismatch";
+            version_unsupported: "version_unsupported";
+            too_large: "too_large";
+            storage_limit_reached: "storage_limit_reached";
+            upload_expired: "upload_expired";
+            storage_unavailable: "storage_unavailable";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>>;
+        report: z.ZodNullable<z.ZodObject<{
+            channels: z.ZodNumber;
+            entries: z.ZodNumber;
+            attachments: z.ZodNumber;
+            historicalMembers: z.ZodNumber;
+            historicalAgents: z.ZodNumber;
+            attachmentBytes: z.ZodNumber;
+            countedBytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** A page of the caller's moves. */
+export type CommunityMoveListResponse = z.infer<typeof CommunityMoveListResponseSchema>;
+/**
+ * `POST /v1/communities/moves` — start a move.
+ *
+ * The caller names the export by size and digest before sending a byte, so a
+ * file too large for a move is refused with `import_too_large`, and one that
+ * would not fit the account with `entitlement_required`, before an upload
+ * starts. Idempotent on the caller's key, like a start.
+ */
+export declare const CommunityMoveStartRequestSchema: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    name: z.ZodString;
+    shortName: z.ZodOptional<z.ZodString>;
+    orgId: z.ZodOptional<z.ZodString>;
+    archiveBytes: z.ZodNumber;
+    archiveSha256: z.ZodString;
+}, z.core.$strip>;
+/** Start moving a community in from an owner export. */
+export type CommunityMoveStartRequest = z.infer<typeof CommunityMoveStartRequestSchema>;
+/**
+ * The header that carries an export's digest on its upload, as lower-case hex.
+ *
+ * The Community server compares it with the bytes it received and refuses the
+ * upload when they differ.
+ */
+export declare const COMMUNITY_ARCHIVE_DIGEST_HEADER: "X-Archive-SHA256";
+/**
+ * Where to send the export file.
+ *
+ * Send the file's exact bytes with `PUT` to `url`, with `token` as a bearer
+ * credential, `Content-Length` set to the declared size, and the declared
+ * digest in the {@link COMMUNITY_ARCHIVE_DIGEST_HEADER} header. The URL is the
+ * Community server's own upload route, so the file goes straight to the host
+ * and never through the hosting service.
+ *
+ * What the Community server answers, in its own error envelope (a JSON body
+ * with a `code`, not this contract's `Problem`):
+ *
+ * - success: the token is spent and the move goes on to `importing`;
+ * - `400 IMPORT_ARCHIVE_INVALID`: the bytes did not match the declared size or
+ *   digest. Nothing is kept, the move stays `awaiting_upload`, and the same
+ *   token may be used again until `expiresAt`;
+ * - a dropped connection part-way: the same, the token still works;
+ * - `401`: the upload window has closed. The move is then `failed` with
+ *   `upload_expired`, and the app starts a new move. A failed move frees its
+ *   short name at once, so the new move can use the same one.
+ */
+export declare const CommunityMoveUploadSchema: z.ZodObject<{
+    url: z.ZodURL;
+    token: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    maxBytes: z.ZodNumber;
+}, z.core.$strip>;
+/** Where and how to send the export file. */
+export type CommunityMoveUpload = z.infer<typeof CommunityMoveUploadSchema>;
+/**
+ * The started move.
+ *
+ * The first answer carries the upload target, and no later answer does: the
+ * token is a credential the service keeps no copy of. `upload` is therefore
+ * null exactly when `replayed` is true. A caller that lost it cancels the move
+ * and starts a new one; cancelling frees the short name at once.
+ */
+export declare const CommunityMoveStartResponseSchema: z.ZodObject<{
+    move: z.ZodObject<{
+        moveId: z.ZodString;
+        communityId: z.ZodString;
+        communityUrl: z.ZodURL;
+        name: z.ZodString;
+        state: z.ZodUnion<readonly [z.ZodEnum<{
+            awaiting_upload: "awaiting_upload";
+            importing: "importing";
+            ready: "ready";
+            failed: "failed";
+            cancelled: "cancelled";
+            claimed: "claimed";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>;
+        failureCode: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+            not_owner_export: "not_owner_export";
+            archive_invalid: "archive_invalid";
+            checksum_mismatch: "checksum_mismatch";
+            version_unsupported: "version_unsupported";
+            too_large: "too_large";
+            storage_limit_reached: "storage_limit_reached";
+            upload_expired: "upload_expired";
+            storage_unavailable: "storage_unavailable";
+        }>, z.ZodPipe<z.ZodString, z.ZodTransform<"unrecognised", string>>]>>;
+        report: z.ZodNullable<z.ZodObject<{
+            channels: z.ZodNumber;
+            entries: z.ZodNumber;
+            attachments: z.ZodNumber;
+            historicalMembers: z.ZodNumber;
+            historicalAgents: z.ZodNumber;
+            attachmentBytes: z.ZodNumber;
+            countedBytes: z.ZodNumber;
+        }, z.core.$strip>>;
+        pollAfterMs: z.ZodNullable<z.ZodNumber>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    upload: z.ZodNullable<z.ZodObject<{
+        url: z.ZodURL;
+        token: z.ZodString;
+        expiresAt: z.ZodISODateTime;
+        maxBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+/** The started move. */
+export type CommunityMoveStartResponse = z.infer<typeof CommunityMoveStartResponseSchema>;
+//# sourceMappingURL=communities.d.ts.map