@endora-commerce/contracts 0.100.0

package/dist/organizations.d.ts

@@ -0,0 +1,938 @@
+import { z } from 'zod';
+import { type FulfilmentStrategy } from './inventory.js';
+/**
+ * Organizations, customer accounts, addresses, invitations — Source of truth
+ * per Principle V. Drives US2 + US3.
+ * See specs/001-b2b-platform-foundation/contracts/organizations.contract.md.
+ */
+/**
+ * Organization lifecycle status (feature 026 consolidation).
+ *
+ *  - `pending_verification` — newly registered, blocks transactions until
+ *    moderator approves (manual moderation mode) or auto-activated.
+ *  - `active` — may transact normally.
+ *  - `blocked` — operator-blocked (replaces the legacy `suspended`); the
+ *    Organization cannot place Orders or Quote Requests; reversible.
+ *  - `rejected` — moderator rejected at registration; terminal.
+ */
+export declare const organizationStatusSchema: z.ZodEnum<{
+    active: "active";
+    rejected: "rejected";
+    blocked: "blocked";
+    pending_verification: "pending_verification";
+}>;
+export type OrganizationStatus = z.infer<typeof organizationStatusSchema>;
+export declare const vatStatusSchema: z.ZodEnum<{
+    vat_payer: "vat_payer";
+    vat_exempt: "vat_exempt";
+    reverse_charge: "reverse_charge";
+}>;
+export type VatStatus = z.infer<typeof vatStatusSchema>;
+/**
+ * Feature 056 — per-organization credit-inheritance mode. Platform-admin only.
+ *
+ *  - `shared_pool` — a descendant with no own credit limit draws against the
+ *    nearest ancestor's pool; concurrent draws across the subtree are serialized
+ *    on the owning ancestor's row (zero double-spend).
+ *  - `independent_default` — the inherited amount is each descendant's own
+ *    effective limit; draws are independent of siblings.
+ *
+ * `null` on an Organization ⇒ fall back to the Settings global default
+ * (`organizations.hierarchy.credit_inheritance_mode`, factory `shared_pool`).
+ */
+export declare const creditInheritanceModeSchema: z.ZodEnum<{
+    shared_pool: "shared_pool";
+    independent_default: "independent_default";
+}>;
+export type CreditInheritanceMode = z.infer<typeof creditInheritanceModeSchema>;
+export declare const addressKindSchema: z.ZodEnum<{
+    delivery: "delivery";
+    billing: "billing";
+}>;
+export type AddressKind = z.infer<typeof addressKindSchema>;
+export declare const organizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    taxId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        rejected: "rejected";
+        blocked: "blocked";
+        pending_verification: "pending_verification";
+    }>;
+    vatStatus: z.ZodEnum<{
+        vat_payer: "vat_payer";
+        vat_exempt: "vat_exempt";
+        reverse_charge: "reverse_charge";
+    }>;
+    isPersonal: z.ZodOptional<z.ZodBoolean>;
+    registeredAddress: z.ZodObject<{
+        street: z.ZodString;
+        city: z.ZodString;
+        postalCode: z.ZodString;
+        country: z.ZodString;
+        companyName: z.ZodOptional<z.ZodString>;
+        taxId: z.ZodOptional<z.ZodString>;
+        recipientName: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    fulfilmentStrategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        any: "any";
+        default_first: "default_first";
+        lowest_stock_first: "lowest_stock_first";
+        highest_stock_first: "highest_stock_first";
+        defined_order: "defined_order";
+    }>>>;
+    fulfilmentStrategyWarehouseOrder: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    path: z.ZodOptional<z.ZodString>;
+    creditInheritanceMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        shared_pool: "shared_pool";
+        independent_default: "independent_default";
+    }>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Organization = z.infer<typeof organizationSchema>;
+/**
+ * A single node in an organization subtree / ancestor chain. `depth` is the
+ * node's absolute depth in the tree (root = 0). Returned pre-order (subtree) or
+ * nearest-first (ancestors).
+ */
+export declare const organizationTreeNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    depth: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        rejected: "rejected";
+        blocked: "blocked";
+        pending_verification: "pending_verification";
+    }>;
+}, z.core.$strip>;
+export type OrganizationTreeNode = z.infer<typeof organizationTreeNodeSchema>;
+/** `GET /admin/organizations/:id/subtree` — descendants (incl. self), pre-order. */
+export declare const organizationSubtreeResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        depth: z.ZodNumber;
+        status: z.ZodEnum<{
+            active: "active";
+            rejected: "rejected";
+            blocked: "blocked";
+            pending_verification: "pending_verification";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OrganizationSubtreeResponse = z.infer<typeof organizationSubtreeResponseSchema>;
+/** `GET /admin/organizations/:id/ancestors` — ancestor chain, nearest-first. */
+export declare const organizationAncestorsResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        depth: z.ZodNumber;
+        status: z.ZodEnum<{
+            active: "active";
+            rejected: "rejected";
+            blocked: "blocked";
+            pending_verification: "pending_verification";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OrganizationAncestorsResponse = z.infer<typeof organizationAncestorsResponseSchema>;
+/**
+ * `POST /admin/organizations/:id/parent` — assign / move / detach parent.
+ * `parentId = null` makes `:id` a root. Path maintenance + cycle/depth checks
+ * are guaranteed server-side (this is the only writable path for `parentId`).
+ */
+export declare const assignOrganizationParentRequestSchema: z.ZodObject<{
+    parentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AssignOrganizationParentRequest = z.infer<typeof assignOrganizationParentRequestSchema>;
+/**
+ * `PUT /admin/organizations/:id/credit-inheritance-mode` — platform-admin only.
+ * `mode = null` ⇒ fall back to the Settings global default.
+ */
+export declare const setCreditInheritanceModeRequestSchema: z.ZodObject<{
+    mode: z.ZodNullable<z.ZodEnum<{
+        shared_pool: "shared_pool";
+        independent_default: "independent_default";
+    }>>;
+}, z.core.$strip>;
+export type SetCreditInheritanceModeRequest = z.infer<typeof setCreditInheritanceModeRequestSchema>;
+export declare const customerAccountSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    email: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    role: z.ZodEnum<{
+        organization_admin: "organization_admin";
+        regular_user: "regular_user";
+    }>;
+    emailVerifiedAt: z.ZodNullable<z.ZodString>;
+    twoFactorEnabled: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CustomerAccount = z.infer<typeof customerAccountSchema>;
+export declare const addressSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    kind: z.ZodEnum<{
+        delivery: "delivery";
+        billing: "billing";
+    }>;
+    recipientName: z.ZodString;
+    street: z.ZodString;
+    city: z.ZodString;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>;
+export type Address = z.infer<typeof addressSchema>;
+export declare const registerOrganizationRequestSchema: z.ZodObject<{
+    organization: z.ZodObject<{
+        name: z.ZodString;
+        taxId: z.ZodString;
+        registeredAddress: z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            postalCode: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strip>;
+        vatStatus: z.ZodOptional<z.ZodEnum<{
+            vat_payer: "vat_payer";
+            vat_exempt: "vat_exempt";
+            reverse_charge: "reverse_charge";
+        }>>;
+    }, z.core.$strip>;
+    firstUser: z.ZodObject<{
+        email: z.ZodString;
+        password: z.ZodString;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+    }, z.core.$strip>;
+    acceptedTermsVersion: z.ZodString;
+}, z.core.$strip>;
+export type RegisterOrganizationRequest = z.infer<typeof registerOrganizationRequestSchema>;
+export declare const emailVerificationRequestSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const passwordResetRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export declare const passwordResetConfirmSchema: z.ZodObject<{
+    token: z.ZodString;
+    newPassword: z.ZodString;
+}, z.core.$strip>;
+export declare const customerLoginRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Outcome of the anonymous-cart → customer-cart merge that runs inside the
+ * customer-login flow (feature 037-cart-merge-on-login).
+ *
+ * Internal shape — split between two `noop_*` variants so the audit /
+ * observability paths can distinguish "anon cart was empty" from "no anon
+ * cart was supplied". The HTTP-facing shape collapses both into a single
+ * `'noop'`; see `cartMergeOutcomePublicSchema` below.
+ */
+export declare const cartMergeOutcomeSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        adopted: "adopted";
+        merged: "merged";
+        noop_empty: "noop_empty";
+        noop_no_anon: "noop_no_anon";
+    }>;
+    movedLineCount: z.ZodNumber;
+    summedLineCount: z.ZodNumber;
+    destinationCartId: z.ZodString;
+}, z.core.$strip>;
+export type CartMergeOutcome = z.infer<typeof cartMergeOutcomeSchema>;
+/**
+ * Public (HTTP) narrowing of `cartMergeOutcomeSchema`. The storefront only
+ * needs three buckets to decide whether to surface the merge-confirmation
+ * toast (`adopted | merged → toast`, `noop → silent`) and the destination
+ * cart id for the next cart read.
+ */
+export declare const cartMergeOutcomePublicSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        adopted: "adopted";
+        merged: "merged";
+        noop: "noop";
+    }>;
+    destinationCartId: z.ZodString;
+}, z.core.$strip>;
+export type CartMergeOutcomePublic = z.infer<typeof cartMergeOutcomePublicSchema>;
+/**
+ * Customer login response. The `cartMerge` field is populated when the
+ * login carries an anonymous-cart cookie; `null` when no anon cookie was
+ * supplied; `outcome: 'noop'` when the cookie was supplied but had no
+ * observable effect (no anon cart, or the anon cart was empty).
+ */
+export declare const customerLoginResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        customerAccount: z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodString;
+            organizationId: z.ZodNullable<z.ZodString>;
+            role: z.ZodEnum<{
+                organization_admin: "organization_admin";
+                regular_user: "regular_user";
+            }>;
+            twoFactorEnabled: z.ZodBoolean;
+        }, z.core.$strip>;
+        cartMerge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                adopted: "adopted";
+                merged: "merged";
+                noop: "noop";
+            }>;
+            destinationCartId: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CustomerLoginResponse = z.infer<typeof customerLoginResponseSchema>;
+export declare const changePasswordRequestSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+}, z.core.$strip>;
+export declare const createAddressRequestSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        delivery: "delivery";
+        billing: "billing";
+    }>;
+    recipientName: z.ZodString;
+    street: z.ZodString;
+    city: z.ZodString;
+    postalCode: z.ZodString;
+    country: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateAddressRequest = z.infer<typeof createAddressRequestSchema>;
+export declare const updateAddressRequestSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        delivery: "delivery";
+        billing: "billing";
+    }>>;
+    recipientName: z.ZodOptional<z.ZodString>;
+    street: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    postalCode: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type UpdateAddressRequest = z.infer<typeof updateAddressRequestSchema>;
+export declare const inviteMemberRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    role: z.ZodOptional<z.ZodEnum<{
+        organization_admin: "organization_admin";
+        regular_user: "regular_user";
+    }>>;
+}, z.core.$strip>;
+export declare const acceptInvitationRequestSchema: z.ZodObject<{
+    password: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+}, z.core.$strip>;
+export declare const changeMemberRoleRequestSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        organization_admin: "organization_admin";
+        regular_user: "regular_user";
+    }>;
+}, z.core.$strip>;
+/** Platform admin — PATCH `/admin/organizations/:id` */
+export declare const adminPatchOrganizationRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    vatStatus: z.ZodOptional<z.ZodEnum<{
+        vat_payer: "vat_payer";
+        vat_exempt: "vat_exempt";
+        reverse_charge: "reverse_charge";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        rejected: "rejected";
+        blocked: "blocked";
+        pending_verification: "pending_verification";
+    }>>;
+    orderConfirmationEmails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fulfilmentStrategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        any: "any";
+        default_first: "default_first";
+        lowest_stock_first: "lowest_stock_first";
+        highest_stock_first: "highest_stock_first";
+        defined_order: "defined_order";
+    }>>>;
+    fulfilmentStrategyWarehouseOrder: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    customFieldValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    expectedUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Platform admin — POST `/admin/organizations/:id/recover-admin-access` */
+export declare const adminRecoverOrgAccessRequestSchema: z.ZodObject<{
+    promoteCustomerAccountId: z.ZodString;
+}, z.core.$strip>;
+/** Platform admin — POST `/admin/organizations/:id/members` (direct create) */
+export declare const adminDirectMemberRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    password: z.ZodString;
+    role: z.ZodOptional<z.ZodEnum<{
+        organization_admin: "organization_admin";
+        regular_user: "regular_user";
+    }>>;
+}, z.core.$strip>;
+/** Platform admin — PATCH member role */
+export declare const adminPatchMemberRoleRequestSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        organization_admin: "organization_admin";
+        regular_user: "regular_user";
+    }>;
+    expectedUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Feature 056 (T032) — Platform admin — PATCH member roll-up capability.
+ * When enabled, this customer login sees/acts across its organization's subtree.
+ */
+export declare const adminSetMemberRollupRequestSchema: z.ZodObject<{
+    subtreeRollupEnabled: z.ZodBoolean;
+    expectedUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AdminSetMemberRollupRequest = z.infer<typeof adminSetMemberRollupRequestSchema>;
+/** Platform admin — PATCH `/admin/organizations/:id/members/:customerAccountId` (profile) */
+export declare const adminPatchMemberProfileRequestSchema: z.ZodObject<{
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    expectedUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const registerOrganizationResponseSchema: z.ZodObject<{
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        taxId: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            rejected: "rejected";
+            blocked: "blocked";
+            pending_verification: "pending_verification";
+        }>;
+        vatStatus: z.ZodEnum<{
+            vat_payer: "vat_payer";
+            vat_exempt: "vat_exempt";
+            reverse_charge: "reverse_charge";
+        }>;
+        isPersonal: z.ZodOptional<z.ZodBoolean>;
+        registeredAddress: z.ZodObject<{
+            street: z.ZodString;
+            city: z.ZodString;
+            postalCode: z.ZodString;
+            country: z.ZodString;
+            companyName: z.ZodOptional<z.ZodString>;
+            taxId: z.ZodOptional<z.ZodString>;
+            recipientName: z.ZodOptional<z.ZodString>;
+            phone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        fulfilmentStrategy: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            any: "any";
+            default_first: "default_first";
+            lowest_stock_first: "lowest_stock_first";
+            highest_stock_first: "highest_stock_first";
+            defined_order: "defined_order";
+        }>>>;
+        fulfilmentStrategyWarehouseOrder: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        path: z.ZodOptional<z.ZodString>;
+        creditInheritanceMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            shared_pool: "shared_pool";
+            independent_default: "independent_default";
+        }>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    customerAccount: z.ZodObject<{
+        id: z.ZodString;
+        organizationId: z.ZodString;
+        email: z.ZodString;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        role: z.ZodEnum<{
+            organization_admin: "organization_admin";
+            regular_user: "regular_user";
+        }>;
+        emailVerifiedAt: z.ZodNullable<z.ZodString>;
+        twoFactorEnabled: z.ZodBoolean;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    emailVerificationSent: z.ZodBoolean;
+}, z.core.$strip>;
+export type RegisterOrganizationResponse = z.infer<typeof registerOrganizationResponseSchema>;
+/**
+ * One row of the admin Organization picker.
+ *
+ * A **projection**, not the `GET /api/v1/admin/organizations` envelope: the
+ * picker renders a label, a status pill and nothing else, and it commits the
+ * `id`. `version` rides along because a caller that picks an Organization in
+ * order to write to it needs the optimistic-concurrency token it already had.
+ *
+ * Published because `@endora-commerce/admin-kit` builds this request itself
+ * (feature 091's P2 — the picker moved into the kit and rebuilt its call from
+ * the published `apiClient`), so the shape crosses a package boundary and
+ * Principle II puts it here. Before P2 it was declared in
+ * `admin/src/modules/organizations/api/organizations-picker-client.ts`, where a
+ * kit component could only reach it by importing a module's admin code.
+ *
+ * The status is `organizationStatusSchema` and not a picker-local enum: the four
+ * members the picker filters on are exactly that schema's, so a second name
+ * would be two spellings of one set with nothing keeping them equal.
+ */
+export declare const organizationPickerListItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    legalName: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        rejected: "rejected";
+        blocked: "blocked";
+        pending_verification: "pending_verification";
+    }>;
+    countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    salesRepAdminUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    memberCount: z.ZodOptional<z.ZodNumber>;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+export type OrganizationPickerListItem = z.infer<typeof organizationPickerListItemSchema>;
+/** One page of picker rows. `nextCursor` is `null` on the last page. */
+export declare const organizationPickerPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        legalName: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            active: "active";
+            rejected: "rejected";
+            blocked: "blocked";
+            pending_verification: "pending_verification";
+        }>;
+        countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        salesRepAdminUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        memberCount: z.ZodOptional<z.ZodNumber>;
+        version: z.ZodNumber;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type OrganizationPickerPage = z.infer<typeof organizationPickerPageSchema>;
+export declare const salesRepAssignmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    adminUserId: z.ZodString;
+    displayName: z.ZodString;
+    email: z.ZodString;
+    assignedAt: z.ZodString;
+    assignedByAdminUserId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SalesRepAssignment = z.infer<typeof salesRepAssignmentSchema>;
+export declare const assignSalesRepRequestSchema: z.ZodObject<{
+    adminUserId: z.ZodString;
+}, z.core.$strip>;
+export type AssignSalesRepRequest = z.infer<typeof assignSalesRepRequestSchema>;
+export declare const salesRepOrganizationSchema: z.ZodObject<{
+    organizationId: z.ZodString;
+    name: z.ZodString;
+    openRfqCount: z.ZodNumber;
+    assignedAt: z.ZodString;
+}, z.core.$strip>;
+export type SalesRepOrganization = z.infer<typeof salesRepOrganizationSchema>;
+export type VatValidationProvider = 'vies' | 'mf_pl' | 'format_only';
+export type VatValidationOutcome = 'validated' | 'failed' | 'deferred' | 'unverified';
+/** The JSONB snapshot the organisation's registered address is stored as. */
+export interface OrganizationRegisteredAddress {
+    street: string;
+    city: string;
+    postalCode: string;
+    country: string;
+}
+/**
+ * An organisation as it crosses a module boundary — a plain shape, never the
+ * ORM entity (FR-011). `nameSearch` is absent: it is a derived column the
+ * entity hooks maintain, "never read or written by callers directly", and
+ * publishing it would invite exactly that.
+ */
+export interface OrganizationRecord {
+    id: string;
+    name: string;
+    legalName: string | null;
+    taxId: string;
+    status: OrganizationStatus;
+    vatStatus: VatStatus;
+    isPersonal: boolean;
+    customerGroupId: string | null;
+    registeredAddress: OrganizationRegisteredAddress;
+    orderConfirmationEmails: string[];
+    vatValidatedAt: Date | null;
+    vatValidationProvider: VatValidationProvider | null;
+    vatValidationOutcome: VatValidationOutcome | null;
+    blockedReason: string | null;
+    blockedAt: Date | null;
+    rejectedReason: string | null;
+    rejectedAt: Date | null;
+    approvedAt: Date | null;
+    approvedByAdminUserId: string | null;
+    requiresCartApproval: boolean;
+    fulfilmentStrategy: FulfilmentStrategy | null;
+    fulfilmentStrategyWarehouseOrder: string[] | null;
+    parentId: string | null;
+    /** Materialised ancestor chain `'/<rootId>/…/<thisId>/'`. */
+    path: string;
+    creditInheritanceMode: CreditInheritanceMode | null;
+    customFieldValues: Record<string, unknown>;
+    /** Optimistic-lock token. Pass it back on a versioned write. */
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+}
+/**
+ * Container name: `organizationDetailsPort`. Owner: `organizations`.
+ *
+ * The union of what eleven modules measurably ask for when they read the
+ * organisation row itself: 24 of the 47 inbound sites are `em.findOne` /
+ * `em.find` on the entity, and between them they touch nearly every column.
+ *
+ * **Why this is a second port and not a wider `OrganizationSnapshot`.** The
+ * kernel's `OrganizationReadPort` (`src/kernel/ports/organizations.ts`) is the
+ * *tenancy projection* — `{ id, status }` plus the two questions Principle XI
+ * asks — and D-55 settled it at what its callers use. `organizationTaxProfilePort`
+ * already declined to widen it, in those words, for the same reason: a tax
+ * profile is one consumer's question. So is a name picker, and so is a
+ * fulfilment override. Widening the snapshot to carry them would make the
+ * kernel declare a domain record.
+ *
+ * The name search is here rather than in each caller because it is not a
+ * `LIKE` on `name`: the column that answers it is the diacritic-folded
+ * `nameSearch`, and two of the three existing callers query `name` instead —
+ * so "a search for lodz finds Łódź" holds in one of them and not in the others.
+ *
+ * When `organizations` is off every method fails closed. The module is the
+ * platform's one tenant concept, so in practice the gate cannot close; it is
+ * registered anyway, because an exception carved into the port machinery costs
+ * more than the predicate does.
+ */
+export interface OrganizationDetailsPort {
+    findById(id: string): Promise<OrganizationRecord | null>;
+    findByIds(ids: readonly string[]): Promise<OrganizationRecord[]>;
+    /** How many of these ids exist — the `count === ids.length` existence check. */
+    countByIds(ids: readonly string[]): Promise<number>;
+    /**
+     * Diacritic-insensitive name search over `nameSearch`, ordered by name.
+     * An empty `query` returns the first `limit` organisations.
+     */
+    searchByName(query: string, limit: number): Promise<OrganizationRecord[]>;
+    /** The same search, ids only — for the order list's organisation filter. */
+    searchIdsByName(query: string): Promise<string[]>;
+}
+/**
+ * Diacritic-insensitive normalisation for the organisation's `name_search`
+ * column and for any query string matched against it.
+ *
+ * The character fold itself is `foldDiacritics` in `text-normalization.ts`,
+ * shared with `admin/` and reachable from `storefront/` (issue #240): it strips
+ * every Unicode combining mark through NFD decomposition and then maps the
+ * handful of precomposed Latin letters NFD does not decompose (notably Polish
+ * `ł`/`Ł`, Scandinavian `ø`/`Ø`, Croatian `đ`/`Đ`, Icelandic `ð`/`Ð`,
+ * `þ`/`Þ`, German `ß`, ligatures `æ` and `œ`). What is specific to an
+ * organisation name is the whitespace policy below, and only that: a name typed
+ * with a double space must match one stored with a single one.
+ *
+ * Published as a **function, not a port** (FR-013): it is pure over its
+ * argument, so switching `organizations` off does not change the answer, and a
+ * gated port answering 503 to "fold these diacritics" would be a bug. The
+ * entity's `@BeforeCreate` / `@BeforeUpdate` hooks and `orders`' list filter
+ * both call it, and they must agree or the filter silently stops matching.
+ *
+ * That agreement is why the fold is characterised rather than merely tested:
+ * `backend/test/unit/organizations/name-search-fold-characterisation.test.ts`
+ * pins the output for every input this function can meet, because a change here
+ * re-folds nothing already written to `name_search` and reports no error when
+ * the two stop agreeing.
+ *
+ * Node natives only (Principle IV).
+ */
+export declare function normalizeOrganizationName(input: string): string;
+/**
+ * Thrown when the organisation a read names does not exist. The kernel's
+ * `OrganizationReadPort` has documented it as `assertCanTransact`'s failure
+ * mode since D-32 while the class itself lived in a module, which is the gap
+ * this publication closes.
+ */
+export declare class OrganizationNotFoundError extends Error {
+    readonly organizationId: string;
+    constructor(organizationId: string);
+}
+/**
+ * Thrown when a write is attempted for an organisation whose status forbids
+ * transacting. Four modules — `carts`, `orders`, `quote_requests` and the
+ * external order intake — catch it by class to turn it into a 409 envelope,
+ * which is why it is published here rather than being a port: an error is a
+ * shape, and `DictionaryReferenceError` in `dictionary.ts` set the precedent.
+ */
+export declare class OrganizationCannotTransactError extends Error {
+    readonly organizationId: string;
+    readonly status: Exclude<OrganizationStatus, 'active'>;
+    constructor(organizationId: string, status: Exclude<OrganizationStatus, 'active'>);
+}
+/** Where a subtree's credit limit is held, and under which mode. */
+export interface OrganizationCreditOwner {
+    /** Nearest ancestor-or-self holding a `CreditLimit` row, or null when none exists. */
+    readonly ownerOrgId: string | null;
+    /** Effective mode: the owner's per-org column, else the Settings global default. */
+    readonly mode: CreditInheritanceMode;
+}
+/**
+ * Container name: `organizationInheritancePort`. Owner: `organizations`.
+ *
+ * `credit_limits` is the only consumer: it asks which organisation in the
+ * hierarchy actually holds the limit that applies here.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `organizations` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrganizationInheritancePort {
+    creditOwner(organizationId: string): Promise<OrganizationCreditOwner>;
+}
+/** What a cart-approval-policy write answers with. */
+export interface CartApprovalPolicyWriteResult {
+    readonly organization: OrganizationRecord;
+    /**
+     * `false` when the row already carried the requested value, so nothing was
+     * written and nothing was audited. It is part of the return type rather than
+     * something the caller re-derives from a read, because the caller's cascade
+     * hangs off it: `carts` resets its pending and approved carts when — and only
+     * when — the policy actually moved to `false`.
+     */
+    readonly changed: boolean;
+}
+/**
+ * Container name: `organizationCartApprovalWritePort`. Owner: `organizations`.
+ *
+ * The per-organisation "an Org Admin must approve a cart before checkout"
+ * policy (feature 027 US4). `carts` drives both surfaces that flip it — the
+ * platform-admin route and the Org-Admin self-service one — but the column is
+ * this module's, so the operation is (issue #175, D-78 step 1).
+ *
+ * The write runs through `CommandBus.run`, so it carries the audit row it had
+ * never had while `carts` was writing the column directly, with the actor
+ * derived from the caller's ambient context (Constitution XIII). The cart
+ * cascade that follows a switch-off stays with `carts`: those are its rows, and
+ * they are audited in its own per-cart trail.
+ *
+ * This module is non-deactivatable, so the gate the port registration applies
+ * cannot be reached; the registration is a `providePort` anyway, for the reason
+ * its siblings give.
+ */
+export interface OrganizationCartApprovalWritePort {
+    setCartApprovalPolicy(organizationId: string, requiresCartApproval: boolean): Promise<CartApprovalPolicyWriteResult>;
+}
+/** The three allow-list kinds an organisation can restrict. */
+export type OrganizationAllowListKind = 'paymentMethodIds' | 'deliveryMethodIds' | 'warehouseIds';
+/**
+ * Container name: `organizationRestrictionPort`. Owner: `organizations`.
+ *
+ * `null` means "no restriction configured — everything is allowed", and it is
+ * deliberately part of the return type rather than something a caller infers
+ * from a thrown error. That is the worked example the composition checklist
+ * cites for putting a degrade inside the owner's implementation: a consumer
+ * that caught an exception here would turn a fail-closed edge into a
+ * fail-open one.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `organizations` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface OrganizationRestrictionPort {
+    allowedIdsFor(organizationId: string, kind: OrganizationAllowListKind): Promise<string[] | null>;
+}
+/**
+ * Container name: `personalOrganizationPort`. Owner: `organizations`.
+ *
+ * Feature 051 — a B2C customer is backed by a single-member personal
+ * organisation, so ordering, RFQ, credit and invoicing work and the tenant
+ * guard isolates each individual as their own tenant. There is no
+ * "no-organization" path (Principle XI), which is why this is idempotent
+ * rather than a create.
+ *
+ * Takes the account **id**, not the account: the entity that used to cross
+ * here is the shape feature 075 removes, and the second `EntityManager`
+ * argument went with it — the one caller already flushes the account before
+ * calling.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `organizations` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface PersonalOrganizationPort {
+    ensureForCustomerAccount(customerAccountId: string): Promise<OrganizationRecord>;
+    /**
+     * D-178 — the organisation an account is moved **to** when an operator
+     * detaches it from a company, and the one it would already be in had it never
+     * joined one.
+     *
+     * It differs from {@link ensureForCustomerAccount} in exactly one way, and
+     * the difference is the whole reason it exists: that method answers with the
+     * account's *current* organisation when it has one, so an account inside a
+     * company gets that company back. This one always answers with the account's
+     * **own** personal organisation, provisioning it if it has never existed.
+     *
+     * It writes no membership. Binding the account is the caller's write on
+     * `customer_accounts`' side of the boundary
+     * (`CustomerAccountLifecycleWritePort.detachToPersonalOrganization`), because
+     * the authority check and the "an organisation keeps an administrator" guard
+     * that must precede it are `customers`' policy.
+     *
+     * Idempotent: the personal organisation's `taxId` is derived from the account
+     * id, so a second call re-finds the row rather than creating a second one.
+     */
+    provisionPersonalOrganization(customerAccountId: string): Promise<OrganizationRecord>;
+    /**
+     * Feature 051, the other end of the same rule — the retention sweep's
+     * cascade. Once the single member of a personal organisation has been
+     * anonymised, the organisation is left with nobody in it and its name is
+     * derived from that person's name, so it is scrubbed and soft-deleted too.
+     *
+     * Answers `null`, and writes nothing, in every case where the cascade does
+     * not apply: an org-less account, an organisation that is not personal, one
+     * already soft-deleted, and one that still has a live member. That is why it
+     * takes the **account** id rather than the organisation's — the caller
+     * (`customers`' anonymisation sweep) knows which customer it just scrubbed
+     * and must not be the one deciding whether the organisation qualifies.
+     *
+     * Idempotent: a second call over the same account finds the organisation
+     * already soft-deleted and answers `null`.
+     */
+    anonymizeIfOrphaned(customerAccountId: string): Promise<OrganizationRecord | null>;
+}
+/** One sales-rep ↔ organisation assignment row. */
+export interface SalesRepAssignmentRow {
+    readonly id: string;
+    readonly organizationId: string;
+    readonly adminUserId: string;
+    readonly assignedByAdminUserId?: string | null;
+    readonly createdAt: Date;
+}
+/**
+ * Container name: `organizationSalesRepScopePort`. Owner: `organizations`.
+ *
+ * The sales-rep assignment relation as other modules see it. `quote_requests`
+ * scopes an admin's RFQ list with it; the admin surfaces read it to decide
+ * whether a rep may see an organisation at all.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `organizations` has an off state at all is its manifest's
+ * `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface SalesRepAssignmentPort {
+    canSeeOrganization(adminUserId: string, organizationId: string): Promise<boolean>;
+    listAssignedOrganizationIds(adminUserId: string): Promise<string[]>;
+    listForOrganization(organizationId: string): Promise<SalesRepAssignmentRow[]>;
+    assign(input: {
+        organizationId: string;
+        adminUserId: string;
+        assignedByAdminUserId?: string | null;
+    }): Promise<SalesRepAssignmentRow>;
+    unassign(input: {
+        organizationId: string;
+        adminUserId: string;
+    }): Promise<boolean>;
+}
+/** The address a VAT registry hands back when it recognises the tax id. */
+export interface VatReturnedAddress {
+    line1?: string | null;
+    line2?: string | null;
+    postalCode?: string | null;
+    city?: string | null;
+    countryCode?: string | null;
+}
+export interface VatValidationResult {
+    outcome: VatValidationOutcome;
+    legalName: string | null;
+    address: VatReturnedAddress | null;
+    errorKind: string | null;
+}
+/**
+ * Container name: `vatValidatorPort`. Owner: `organizations`.
+ *
+ * Pluggable VAT-ID validator (feature 026 US7), published so `customers` can
+ * name the shape without naming a file in `organizations`.
+ *
+ * **Owner off:** the seam fails closed — resolving the port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`. That is
+ * not the same thing as the `deferred` outcome below: `deferred` is the
+ * *registry* being unreachable, which the caller may retry, while a refused
+ * resolution says the platform is not offering the check at all.
+ *
+ * Every adapter MUST degrade safely: a transient network failure or a
+ * provider-side 5xx returns `{ outcome: 'deferred', errorKind: … }` rather
+ * than throwing. A clean "not registered" response returns
+ * `{ outcome: 'failed', errorKind: 'not_found' }`. Only `validated` carries
+ * the optional `legalName` + `address` payloads the auto-fill flow consumes.
+ */
+export interface VatValidator {
+    readonly provider: VatValidationProvider;
+    validate(input: {
+        taxId: string;
+        /** Optional country hint extracted upstream (VIES needs the country split). */
+        countryCode?: string | undefined;
+    }): Promise<VatValidationResult>;
+}
+/**
+ * Container name: `organizationTaxProfilePort`. Owner: `organizations`.
+ *
+ * The Organization facts a VAT rate depends on (T143c).
+ *
+ * `country` is nullable because the caller's fallback is a business rule
+ * (`'PL'`, in the Quote Requests resolver) and belongs where that rule is
+ * written, not here — a port that invented a country would make an
+ * unregistered address indistinguishable from a Polish one.
+ *
+ * Deliberately not a widening of the kernel's `OrganizationSnapshot`. That
+ * shape is the tenancy projection every module reads; a tax profile is one
+ * consumer's question, and D-55 settled the snapshot at what its callers
+ * actually use.
+ *
+ * **Owner off:** the seam fails closed — resolving the port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`. The Quote
+ * Requests tax closure deliberately carries no `catch` (issue #84): quoting
+ * 0 % on an operator's behalf is worse than failing.
+ *
+ * It is declared here rather than in `organizations`' own `./backend` because
+ * a port's type argument is a contract type and never the provider's file
+ * (composition checklist item 3). The production composition root resolves this
+ * name, and `specs/110-instance-repository/` T118 moves that read into
+ * `@endora-commerce/platform`, where naming a module is D-52/D-53's refusal.
+ */
+export interface OrganizationTaxProfilePort {
+    taxProfileOf(organizationId: string): Promise<{
+        vatStatus: 'vat_payer' | 'vat_exempt' | 'reverse_charge';
+        country: string | null;
+    } | null>;
+}
+//# sourceMappingURL=organizations.d.ts.map