@vindentech/api-client 0.3.0-next.18 → 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;
@@ -2435,77 +2560,6 @@ export interface PlaceOrderResultDto {
     orderNumber: number;
     salesOrders: PlacedSalesOrderDto[];
 }
-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 type TransportServiceDtoSalesOrderType = typeof TransportServiceDtoSalesOrderType[keyof typeof TransportServiceDtoSalesOrderType];
 export declare const TransportServiceDtoSalesOrderType: {
     readonly PICKUP: "PICKUP";
@@ -8152,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";
@@ -8252,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";
@@ -8513,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";
@@ -8568,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;
@@ -8604,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";
@@ -8683,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).