@vindentech/api-client 0.3.0-next.17 → 0.3.0-next.19

package/dist/generated/index.schemas.d.ts

@@ -581,6 +581,60 @@ export interface OrderTransitionResultDto {
     newStatus: OrderTransitionResultDtoNewStatus;
     transitionedAt: string;
 }
+export interface ReceiveAtWarehouseDto {
+    /** The container the collected goods were unloaded onto at the warehouse. */
+    containerId: string;
+}
+/**
+ * Always RECEIVED.
+ */
+export type ReceivedAtWarehousePodDtoStatus = typeof ReceivedAtWarehousePodDtoStatus[keyof typeof ReceivedAtWarehousePodDtoStatus];
+export declare const ReceivedAtWarehousePodDtoStatus: {
+    readonly RECEIVED: "RECEIVED";
+};
+export interface ReceivedAtWarehousePodDto {
+    podId: string;
+    /** Always RECEIVED. */
+    status: ReceivedAtWarehousePodDtoStatus;
+    /** The MOVE movement appended for this pod. */
+    movementId: string;
+}
+/**
+ * Always IN_TRANSIT.
+ */
+export type ReceiveAtWarehouseResultDtoOldStatus = typeof ReceiveAtWarehouseResultDtoOldStatus[keyof typeof ReceiveAtWarehouseResultDtoOldStatus];
+export declare const ReceiveAtWarehouseResultDtoOldStatus: {
+    readonly IN_TRANSIT: "IN_TRANSIT";
+};
+/**
+ * Always RECEIVED.
+ */
+export type ReceiveAtWarehouseResultDtoNewStatus = typeof ReceiveAtWarehouseResultDtoNewStatus[keyof typeof ReceiveAtWarehouseResultDtoNewStatus];
+export declare const ReceiveAtWarehouseResultDtoNewStatus: {
+    readonly RECEIVED: "RECEIVED";
+};
+export interface ReceiveAtWarehouseResultDto {
+    salesOrderId: string;
+    /** Always IN_TRANSIT. */
+    oldStatus: ReceiveAtWarehouseResultDtoOldStatus;
+    /** Always RECEIVED. */
+    newStatus: ReceiveAtWarehouseResultDtoNewStatus;
+    /** ISO-8601 receipt timestamp. */
+    receivedAt: string;
+    /** The receiving container. */
+    containerId: string;
+    /**
+     * The container's current position, or null when it is unplaced.
+     * @nullable
+     */
+    positionId: string | null;
+    /** The order's warehouse after the command — backfilled from the container when the order had none. */
+    warehouseId: string;
+    /** Every IDENTIFIED pod that was moved onto the container. */
+    placedPods: ReceivedAtWarehousePodDto[];
+    /** True when this response is an idempotent replay. */
+    idempotent: boolean;
+}
 export interface DeliverAllDto {
     /** An existing file_asset id (kind POD) to link to the leg as proof_of_delivery. */
     proofOfDeliveryFileId?: string;
@@ -1594,6 +1648,77 @@ export interface UpdateIdentityNumberDto {
     /** Swedish personal identity number — YYMMDDNNNN, YYMMDD-NNNN, YYMMDD+NNNN, YYYYMMDDNNNN or YYYYMMDD-NNNN, with a valid Luhn check digit. Stored digits-only. Never returned by any endpoint. */
     personalIdentityNumber: string;
 }
+export interface ServicePointAddressDto {
+    /** @nullable */
+    street: string | null;
+    /** @nullable */
+    postalCode: string | null;
+    /** @nullable */
+    city: string | null;
+    /** @nullable */
+    municipality: string | null;
+    /** ISO 3166-1 alpha-2 */
+    countryCode: string;
+    /**
+     * Where to find the point once on site (e.g. which part of a building).
+     * @nullable
+     */
+    specificLocation: string | null;
+    /** @nullable */
+    latitude: number | null;
+    /** @nullable */
+    longitude: number | null;
+}
+export interface ServicePointOpeningHoursDto {
+    /** Provider-supplied day name. */
+    dayOfWeek: string;
+    /**
+     * Local time, provider-formatted.
+     * @nullable
+     */
+    opens: string | null;
+    /**
+     * Local time, provider-formatted.
+     * @nullable
+     */
+    closes: string | null;
+    open24h: boolean;
+    closed: boolean;
+}
+export type ServicePointDtoProvider = typeof ServicePointDtoProvider[keyof typeof ServicePointDtoProvider];
+export declare const ServicePointDtoProvider: {
+    readonly POSTI: "POSTI";
+};
+export type ServicePointDtoType = typeof ServicePointDtoType[keyof typeof ServicePointDtoType];
+export declare const ServicePointDtoType: {
+    readonly PARCEL_LOCKER: "PARCEL_LOCKER";
+    readonly PICKUP_POINT: "PICKUP_POINT";
+};
+export interface ServicePointDto {
+    /** Provider-scoped opaque id. This is the value to send back as the cart's servicePointId. */
+    id: string;
+    provider: ServicePointDtoProvider;
+    /** Display name for the picker. */
+    name: string;
+    type: ServicePointDtoType;
+    /**
+     * Host business the point sits inside, when it is not standalone.
+     * @nullable
+     */
+    careOf: string | null;
+    /**
+     * Provider routing code for this point — what a shipping/label call needs to address a parcel here.
+     * @nullable
+     */
+    routingServiceCode: string | null;
+    /**
+     * Distance from the searched location, when the provider reports one.
+     * @nullable
+     */
+    distanceInMeters: number | null;
+    address: ServicePointAddressDto;
+    openingHours: ServicePointOpeningHoursDto[];
+}
 export interface AnonymousSessionDto {
     /** Opaque bearer token for the anonymous session. Send it as the X-Session-Token header on guest-capable endpoints. Shown once — it is stored only as a hash. */
     sessionToken: string;
@@ -5366,6 +5491,45 @@ export interface UnidentifyResultDto {
     /** True when this response replays a previous run of the key. */
     idempotent: boolean;
 }
+export interface PickupLabelProductDto {
+    productId: string;
+    /**
+     * Display name (placeholder_name ?? name).
+     * @nullable
+     */
+    name: string | null;
+    /** @nullable */
+    primaryImageStorageKey: string | null;
+    /**
+     * The product_image row backing primaryImageStorageKey, when one exists.
+     * @nullable
+     */
+    productImageId: string | null;
+}
+/**
+ * Routing verdict for the scanned label. `returning` is the only outcome carrying data.
+ */
+export type PickupLabelLookupDtoOutcome = typeof PickupLabelLookupDtoOutcome[keyof typeof PickupLabelLookupDtoOutcome];
+export declare const PickupLabelLookupDtoOutcome: {
+    readonly not_found: "not_found";
+    readonly returning: "returning";
+    readonly label_in_use: "label_in_use";
+    readonly other_customer: "other_customer";
+};
+/**
+ * @nullable
+ */
+export type PickupLabelLookupDtoProduct = PickupLabelProductDto | null;
+export interface PickupLabelLookupDto {
+    /** Routing verdict for the scanned label. `returning` is the only outcome carrying data. */
+    outcome: PickupLabelLookupDtoOutcome;
+    /** @nullable */
+    product: PickupLabelLookupDtoProduct;
+    /** @nullable */
+    itemId: string | null;
+    /** @nullable */
+    podId: string | null;
+}
 export interface CreateDamageReportDto {
     /** The item the condition lives on (G1). */
     itemId: string;
@@ -8042,6 +8206,44 @@ export interface PreferenceDto {
     source: string;
     updatedAt: string;
 }
+export interface PreferenceSubjectDto {
+    /** The subject's Keycloak sub. Mutually exclusive with `address`. */
+    userSub?: string;
+    /** The subject's email or phone. Mutually exclusive with `userSub`. */
+    address?: string;
+}
+export type UpsertPreferenceDtoCategory = typeof UpsertPreferenceDtoCategory[keyof typeof UpsertPreferenceDtoCategory];
+export declare const UpsertPreferenceDtoCategory: {
+    readonly marketing: "marketing";
+    readonly operational: "operational";
+    readonly transactional: "transactional";
+    readonly billing: "billing";
+    readonly security: "security";
+    readonly system: "system";
+};
+/**
+ * `null` applies the choice to every channel for the category.
+ * @nullable
+ */
+export type UpsertPreferenceDtoChannel = typeof UpsertPreferenceDtoChannel[keyof typeof UpsertPreferenceDtoChannel] | null;
+export declare const UpsertPreferenceDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export interface UpsertPreferenceDto {
+    /** Staff surface only. On `/v1/me` the subject is the caller's JWT `sub` and this field is rejected. */
+    subject?: PreferenceSubjectDto;
+    category: UpsertPreferenceDtoCategory;
+    /**
+     * `null` applies the choice to every channel for the category.
+     * @nullable
+     */
+    channel: UpsertPreferenceDtoChannel;
+    /** `false` is the opt-out. `true` is an explicit restored opt-in, which is kept as a row so the trail shows the choice was reversed. */
+    isEnabled: boolean;
+}
 export type AddressVerdictDtoCategory = typeof AddressVerdictDtoCategory[keyof typeof AddressVerdictDtoCategory];
 export declare const AddressVerdictDtoCategory: {
     readonly marketing: "marketing";
@@ -8142,6 +8344,28 @@ export interface PaginatedSuppressionsDto {
     /** Effective rows skipped applied. */
     offset: number;
 }
+export type CreateSuppressionDtoChannel = typeof CreateSuppressionDtoChannel[keyof typeof CreateSuppressionDtoChannel];
+export declare const CreateSuppressionDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export interface CreateSuppressionDto {
+    channel: CreateSuppressionDtoChannel;
+    /** Email or E.164 phone; normalized server-side. */
+    address: string;
+    /** When the block lapses. Omit for a permanent block. */
+    expiresAt?: string;
+    /** Why this address is being blocked. Recorded in the admin action. */
+    note?: string;
+}
+export interface ReleaseSuppressionDto {
+    /** Why the block is being lifted. Recorded in the admin action. */
+    reason: string;
+    /** Required to release a hard_bounce / complaint / sms_stop / provider_suppression row. Recorded in the admin action. */
+    acknowledgeReputationRisk?: boolean;
+}
 export type NotificationDispatchDtoChannel = typeof NotificationDispatchDtoChannel[keyof typeof NotificationDispatchDtoChannel];
 export declare const NotificationDispatchDtoChannel: {
     readonly email: "email";
@@ -8403,6 +8627,55 @@ export interface NotificationDispatchDetailDto {
     bodyRetained: boolean;
     deliveryEvents: DeliveryEventDto[];
 }
+/**
+ * Transient `failed` only. Any other status is refused.
+ */
+export type ResendBatchFilterDtoStatus = typeof ResendBatchFilterDtoStatus[keyof typeof ResendBatchFilterDtoStatus];
+export declare const ResendBatchFilterDtoStatus: {
+    readonly failed: "failed";
+};
+export interface ResendBatchFilterDto {
+    /** Transient `failed` only. Any other status is refused. */
+    status: ResendBatchFilterDtoStatus;
+    /** Narrow to one event. */
+    eventKey?: string;
+    /** Required. The window is what makes the count and the resend partition-pruned. */
+    createdFrom: string;
+    createdTo: string;
+}
+export interface ResendBatchDto {
+    filter: ResendBatchFilterDto;
+    /** The count the operator was shown. The server re-counts and refuses the batch if the number moved — a bulk send against a number nobody saw is the failure mode this exists to prevent. */
+    expectedCount: number;
+    /** Explicit confirmation (04 §11). Anything but `true` is refused. */
+    confirm: boolean;
+}
+export interface ResendBatchResultDto {
+    /** New dispatch rows created. */
+    created: number;
+    /** How many of those landed terminal because the re-run gate blocked them (now-suppressed or opted-out addresses). They are created and auditable, but nothing will be sent. */
+    skippedByGate: number;
+}
+/**
+ * What the re-run send-time gate decided. `suppressed` / `skipped_opt_out` mean the resend landed as a terminal row and no message will go out — the UI cannot punch through a hard block.
+ */
+export type ResendResultDtoGateOutcome = typeof ResendResultDtoGateOutcome[keyof typeof ResendResultDtoGateOutcome];
+export declare const ResendResultDtoGateOutcome: {
+    readonly queued: "queued";
+    readonly suppressed: "suppressed";
+    readonly skipped_opt_out: "skipped_opt_out";
+};
+export interface ResendResultDto {
+    /** The NEW dispatch. The original is never mutated. */
+    notificationDispatchId: string;
+    /** What the re-run send-time gate decided. `suppressed` / `skipped_opt_out` mean the resend landed as a terminal row and no message will go out — the UI cannot punch through a hard block. */
+    gateOutcome: ResendResultDtoGateOutcome;
+    /**
+     * Why the gate blocked it, in the vocabulary the dispatch row records.
+     * @nullable
+     */
+    gateReason: string | null;
+}
 export type DispatchStatusCountDtoStatus = typeof DispatchStatusCountDtoStatus[keyof typeof DispatchStatusCountDtoStatus];
 export declare const DispatchStatusCountDtoStatus: {
     readonly queued: "queued";
@@ -8458,6 +8731,10 @@ export interface NotificationRequestDto {
     /** Total dispatches fanned out from this request. */
     dispatchCount: number;
 }
+export interface ReprocessResultDto {
+    /** The outbox key of the re-emitted event. A reprocess puts the original event back on the pipeline rather than writing a request row: Phase A creates the new request when it consumes the event, so this key — not a request id — is what correlates the command to the fan-out it caused. The original request is never mutated. */
+    outboxEventKey: string;
+}
 export interface HealthRateWindowDto {
     numerator: number;
     denominator: number;
@@ -8494,6 +8771,10 @@ export interface NotificationSettingsDto {
     /** @nullable */
     smsSpendCeiling: number | null;
 }
+export interface SendPauseDto {
+    /** Why sending is being paused or resumed. Recorded in the admin action. */
+    reason: string;
+}
 export type SenderIdentityDtoChannel = typeof SenderIdentityDtoChannel[keyof typeof SenderIdentityDtoChannel];
 export declare const SenderIdentityDtoChannel: {
     readonly email: "email";
@@ -8573,6 +8854,257 @@ export interface SenderIdentityDetailDto {
     /** DKIM/DNS records to publish for an email identity. Empty until the SES read lands with the verify command in the write slice. */
     dnsRecords: SenderDnsRecordDto[];
 }
+export type CreateSenderIdentityDtoChannel = typeof CreateSenderIdentityDtoChannel[keyof typeof CreateSenderIdentityDtoChannel];
+export declare const CreateSenderIdentityDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export type CreateSenderIdentityDtoProvider = typeof CreateSenderIdentityDtoProvider[keyof typeof CreateSenderIdentityDtoProvider];
+export declare const CreateSenderIdentityDtoProvider: {
+    readonly ses: "ses";
+    readonly aws_eum_sms: "aws_eum_sms";
+    readonly apns: "apns";
+    readonly fcm: "fcm";
+};
+export interface CreateSenderIdentityDto {
+    channel: CreateSenderIdentityDtoChannel;
+    provider: CreateSenderIdentityDtoProvider;
+    /** Email address or domain for SES; sender ID / origination number for SMS. */
+    identityValue: string;
+    /** The From name recipients see. */
+    displayName?: string;
+    /** SES configuration-set name / EUM config set or pool ARN. An opaque pointer to a Pulumi-provisioned resource — never a credential. May be filled in later by platform tooling. */
+    providerConfigRef?: string;
+    /** SES identity ARN / EUM pool or sender-ID ARN. Same rules as `providerConfigRef`. */
+    providerIdentityArn?: string;
+}
+export interface UpdateSenderIdentityDto {
+    /** @nullable */
+    displayName?: string | null;
+    /** Make this the channel's default. The swap is atomic — the partial UNIQUE admits one default per channel, so the previous default is demoted in the same transaction. Passing `false` on the current default is refused: a channel with enabled rules and no default has no sender. */
+    isDefault?: boolean;
+}
+/**
+ * The event payload, exactly as the producer would emit it.
+ */
+export type SimulateDtoPayload = {
+    [key: string]: unknown;
+};
+export interface SimulateDto {
+    eventKey: string;
+    /** Pin a contract version. Defaults to the event's active version. */
+    eventVersion?: number;
+    /** The event payload, exactly as the producer would emit it. */
+    payload: SimulateDtoPayload;
+    /** The tenant to simulate against. Must be the tenant this host resolves to — enterprise tenants have their own hostname and their own database, so simulating another tenant means calling that tenant's API, not passing its id here. */
+    tenantId?: string;
+}
+export interface SimulationContractValidationDto {
+    valid: boolean;
+    /** One line per offending instance path. */
+    errors: string[];
+}
+export type SimulationMatchedRuleDtoChannel = typeof SimulationMatchedRuleDtoChannel[keyof typeof SimulationMatchedRuleDtoChannel];
+export declare const SimulationMatchedRuleDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export type SimulationMatchedRuleDtoCategory = typeof SimulationMatchedRuleDtoCategory[keyof typeof SimulationMatchedRuleDtoCategory];
+export declare const SimulationMatchedRuleDtoCategory: {
+    readonly marketing: "marketing";
+    readonly operational: "operational";
+    readonly transactional: "transactional";
+    readonly billing: "billing";
+    readonly security: "security";
+    readonly system: "system";
+};
+export interface SimulationMatchedRuleDto {
+    ruleId: string;
+    channel: SimulationMatchedRuleDtoChannel;
+    category: SimulationMatchedRuleDtoCategory;
+    /** Whether fan-out would act on this rule. */
+    fired: boolean;
+    /**
+     * Why it did not fire. `rule_disabled` is the only reason in v1.
+     * @nullable
+     */
+    skipReason: string | null;
+}
+export type SimulationRecipientDtoDelivery = typeof SimulationRecipientDtoDelivery[keyof typeof SimulationRecipientDtoDelivery];
+export declare const SimulationRecipientDtoDelivery: {
+    readonly to: "to";
+    readonly cc: "cc";
+    readonly bcc: "bcc";
+};
+/**
+ * The `resolution_reason` snapshot: spec index, kind, and the role/path it named.
+ */
+export type SimulationRecipientDtoResolutionReason = {
+    [key: string]: unknown;
+};
+export interface SimulationRecipientDto {
+    ruleId: string;
+    /** Normalized, as the dispatch row would record it. */
+    address: string;
+    /** messaging.recipient_kind — which spec produced it. */
+    kind: string;
+    delivery: SimulationRecipientDtoDelivery;
+    /** The `resolution_reason` snapshot: spec index, kind, and the role/path it named. */
+    resolutionReason: SimulationRecipientDtoResolutionReason;
+    /**
+     * `unresolvable_recipient` / `invalid_recipient` when the spec produced nothing usable. Fan-out writes a terminal `failed` dispatch for these rather than dropping them.
+     * @nullable
+     */
+    error: string | null;
+}
+export type SimulationPolicyDecisionDtoCategory = typeof SimulationPolicyDecisionDtoCategory[keyof typeof SimulationPolicyDecisionDtoCategory];
+export declare const SimulationPolicyDecisionDtoCategory: {
+    readonly marketing: "marketing";
+    readonly operational: "operational";
+    readonly transactional: "transactional";
+    readonly billing: "billing";
+    readonly security: "security";
+    readonly system: "system";
+};
+export type SimulationPolicyDecisionDtoChannel = typeof SimulationPolicyDecisionDtoChannel[keyof typeof SimulationPolicyDecisionDtoChannel];
+export declare const SimulationPolicyDecisionDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export type SimulationPolicyDecisionDtoVerdict = typeof SimulationPolicyDecisionDtoVerdict[keyof typeof SimulationPolicyDecisionDtoVerdict];
+export declare const SimulationPolicyDecisionDtoVerdict: {
+    readonly send: "send";
+    readonly suppressed: "suppressed";
+    readonly skipped_opt_out: "skipped_opt_out";
+};
+/**
+ * The matrix rule that decided it.
+ */
+export type SimulationPolicyDecisionDtoMatrixRule = typeof SimulationPolicyDecisionDtoMatrixRule[keyof typeof SimulationPolicyDecisionDtoMatrixRule];
+export declare const SimulationPolicyDecisionDtoMatrixRule: {
+    readonly hard_bounce_always_wins: "hard_bounce_always_wins";
+    readonly complaint_always_wins: "complaint_always_wins";
+    readonly sms_stop_legal_hard_block: "sms_stop_legal_hard_block";
+    readonly manual_suppression: "manual_suppression";
+    readonly provider_suppression: "provider_suppression";
+    readonly preference_opt_out: "preference_opt_out";
+    readonly billing_category_opt_out_ignored: "billing_category_opt_out_ignored";
+    readonly category_not_preference_suppressible: "category_not_preference_suppressible";
+    readonly no_block: "no_block";
+};
+export interface SimulationPolicyDecisionDto {
+    address: string;
+    category: SimulationPolicyDecisionDtoCategory;
+    channel: SimulationPolicyDecisionDtoChannel;
+    verdict: SimulationPolicyDecisionDtoVerdict;
+    /** The matrix rule that decided it. */
+    matrixRule: SimulationPolicyDecisionDtoMatrixRule;
+    /**
+     * The suppression or preference row behind the verdict.
+     * @nullable
+     */
+    recordId: string | null;
+}
+export type SimulationTemplateCandidateDtoScope = typeof SimulationTemplateCandidateDtoScope[keyof typeof SimulationTemplateCandidateDtoScope];
+export declare const SimulationTemplateCandidateDtoScope: {
+    readonly bound: "bound";
+    readonly org_override: "org_override";
+    readonly tenant_default: "tenant_default";
+    readonly system: "system";
+};
+export interface SimulationTemplateCandidateDto {
+    scope: SimulationTemplateCandidateDtoScope;
+    notificationTemplateId: string;
+    notificationTemplateVersionId: string;
+    locale: string;
+    /**
+     * Lower is a better locale match; null means the locale is not an acceptable fallback.
+     * @nullable
+     */
+    localeRank: number | null;
+    chosen: boolean;
+}
+export interface SimulationTemplateResolutionDto {
+    ruleId: string;
+    /** @nullable */
+    notificationTemplateId: string | null;
+    /** @nullable */
+    notificationTemplateVersionId: string | null;
+    /** @nullable */
+    locale: string | null;
+    /** Every published candidate considered, in precedence order — bound, then org override, tenant default, system — with the winner marked. The answer to "why that template?". */
+    fallbackChain: SimulationTemplateCandidateDto[];
+}
+export interface SimulationRenderedPreviewDto {
+    ruleId: string;
+    subject: string;
+    html: string;
+    text: string;
+    /** @nullable */
+    smsSegments: number | null;
+    sanitizationWarnings: SanitizationWarningDto[];
+    /** Non-fatal field render errors. */
+    renderErrors: string[];
+}
+export type SimulationVerdictDtoChannel = typeof SimulationVerdictDtoChannel[keyof typeof SimulationVerdictDtoChannel];
+export declare const SimulationVerdictDtoChannel: {
+    readonly email: "email";
+    readonly sms: "sms";
+    readonly push: "push";
+    readonly webhook: "webhook";
+};
+export type SimulationVerdictDtoWouldWriteStatus = typeof SimulationVerdictDtoWouldWriteStatus[keyof typeof SimulationVerdictDtoWouldWriteStatus];
+export declare const SimulationVerdictDtoWouldWriteStatus: {
+    readonly queued: "queued";
+    readonly rendering: "rendering";
+    readonly render_failed: "render_failed";
+    readonly suppressed: "suppressed";
+    readonly skipped_opt_out: "skipped_opt_out";
+    readonly skipped_disabled: "skipped_disabled";
+    readonly skipped_cost_capped: "skipped_cost_capped";
+    readonly sent: "sent";
+    readonly delivered: "delivered";
+    readonly opened: "opened";
+    readonly clicked: "clicked";
+    readonly soft_bounced: "soft_bounced";
+    readonly hard_bounced: "hard_bounced";
+    readonly complaint: "complaint";
+    readonly failed: "failed";
+    readonly dead_lettered: "dead_lettered";
+    readonly permanently_failed: "permanently_failed";
+};
+export interface SimulationVerdictDto {
+    ruleId: string;
+    address: string;
+    channel: SimulationVerdictDtoChannel;
+    wouldWriteStatus: SimulationVerdictDtoWouldWriteStatus;
+    /**
+     * The `error_message` the row would carry, when the status is not `queued`.
+     * @nullable
+     */
+    detail: string | null;
+}
+export interface SimulationResultDto {
+    eventKey: string;
+    eventVersion: number;
+    contractValidation: SimulationContractValidationDto;
+    matchedRules: SimulationMatchedRuleDto[];
+    resolvedRecipients: SimulationRecipientDto[];
+    /** After (address, channel) dedup, keeping the strongest delivery level — the set fan-out would actually create rows for. */
+    dedupedRecipients: SimulationRecipientDto[];
+    policyDecisions: SimulationPolicyDecisionDto[];
+    templateResolution: SimulationTemplateResolutionDto[];
+    renderedPreview: SimulationRenderedPreviewDto[];
+    verdicts: SimulationVerdictDto[];
+    /** True when this tenant's sending is paused. Phase A still fans out; Phase B would park every `queued` row until the pause lifts — so the verdicts above are what WOULD be written, not what would be delivered today. */
+    sendingPaused: boolean;
+}
 export type OrdersControllerListV1Params = {
     /**
      * Max rows to return (1–100).
@@ -8764,6 +9296,33 @@ export type CarriersControllerListMethodsV1Params = {
      */
     isActive?: boolean;
 };
+export type ServicePointsControllerListV1Params = {
+    /**
+     * Postal code to search near.
+     */
+    zipCode: string;
+    /**
+     * ISO 3166-1 alpha-2
+     */
+    countryCode: string;
+    /**
+     * Defaults to POSTI, the only provider wired today.
+     */
+    provider?: ServicePointsControllerListV1Provider;
+    /**
+     * Narrow to one kind of service point. Omit for both.
+     */
+    type?: ServicePointsControllerListV1Type;
+};
+export type ServicePointsControllerListV1Provider = typeof ServicePointsControllerListV1Provider[keyof typeof ServicePointsControllerListV1Provider];
+export declare const ServicePointsControllerListV1Provider: {
+    readonly POSTI: "POSTI";
+};
+export type ServicePointsControllerListV1Type = typeof ServicePointsControllerListV1Type[keyof typeof ServicePointsControllerListV1Type];
+export declare const ServicePointsControllerListV1Type: {
+    readonly PARCEL_LOCKER: "PARCEL_LOCKER";
+    readonly PICKUP_POINT: "PICKUP_POINT";
+};
 export type CheckoutControllerAvailableServicesV1Params = {
     /**
      * Recipient zip code — resolves the service zone
@@ -9318,25 +9877,6 @@ export declare const LookupsControllerListV1Kind: {
     readonly 'transport-slot-kind': "transport-slot-kind";
     readonly 'organization-type': "organization-type";
 };
-export type ServicePointsControllerListV1Params = {
-    /**
-     * Postal code to search near.
-     */
-    zipCode?: string;
-    /**
-     * ISO 3166-1 alpha-2
-     */
-    countryCode?: string;
-    provider?: ServicePointsControllerListV1Provider;
-    /**
-     * Provider-specific service-point type filter.
-     */
-    type?: string;
-};
-export type ServicePointsControllerListV1Provider = typeof ServicePointsControllerListV1Provider[keyof typeof ServicePointsControllerListV1Provider];
-export declare const ServicePointsControllerListV1Provider: {
-    readonly POSTI: "POSTI";
-};
 export type IntegrationsControllerGetByIdV1200 = StripeAccountDto | FortnoxAccountDto;
 export type BillingAccountsControllerListAccountsV1Params = {
     /**