clarion-shared-types 1.0.85 → 1.0.87

package/dist/types/modules/partner/interfaces/partner-integration.dto.d.ts

@@ -0,0 +1,86 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { PartnerIntegrationEnvironment, PartnerIntegrationStatus, PartnerProviderCode, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+import { PartnerCoverageRuleDto } from './partner-coverage-rule.dto';
+/**
+ * Frontend view of an organization's partnership with a third-party service
+ * partner.
+ *
+ * NEVER carries the credential value, and never even the reference: the backend
+ * returns `credentialConfigured` instead, so the admin can show "configured" or
+ * "not configured" without any part of the secret reaching the browser.
+ */
+export interface PartnerIntegrationDto {
+    id: number;
+    organizationId: number;
+    controlCentreId: number | null;
+    providerCode: PartnerProviderCode;
+    name: string;
+    environment: PartnerIntegrationEnvironment;
+    baseUrl: string;
+    credentialConfigured: boolean;
+    configuration: Record<string, unknown>;
+    capabilities: PartnerServiceCapability[];
+    routingMode: PartnerRoutingMode;
+    approvalWindowMinutes: number | null;
+    enabled: boolean;
+    priority: number;
+    countryCode: CountryCode;
+    status: PartnerIntegrationStatus;
+    partnerContactName: string | null;
+    partnerContactPhone: string | null;
+    partnerContactEmail: string | null;
+    lastHealthCheckAt: string | null;
+    lastSuccessAt: string | null;
+    lastErrorAt: string | null;
+    lastErrorCode: string | null;
+    lastErrorMessage: string | null;
+    createdBy: number | null;
+    updatedBy: number | null;
+    createdAt: string;
+    updatedAt: string;
+    /** Present on the detail endpoint. */
+    coverageRules?: PartnerCoverageRuleDto[];
+}
+export interface CreatePartnerIntegrationDto {
+    /** Super-Admin only: which tenant the partnership belongs to. */
+    organizationId?: number;
+    controlCentreId?: number;
+    providerCode: PartnerProviderCode;
+    name: string;
+    environment?: PartnerIntegrationEnvironment;
+    /** Defaults to the adapter's base URL for the chosen environment. */
+    baseUrl?: string;
+    /** A secret NAME/reference - never the credential value. */
+    credentialReference: string;
+    configuration?: Record<string, unknown>;
+    capabilities: PartnerServiceCapability[];
+    /** Defaults to MANUAL, so a new partnership never dispatches unattended. */
+    routingMode?: PartnerRoutingMode;
+    approvalWindowMinutes?: number;
+    enabled?: boolean;
+    priority?: number;
+    countryCode?: CountryCode;
+    partnerContactName?: string;
+    partnerContactPhone?: string;
+    partnerContactEmail?: string;
+}
+/**
+ * `providerCode` and `organizationId` are deliberately absent: changing either
+ * would repoint an existing dispatch history at a different partner or tenant,
+ * so a move is a delete and a create.
+ */
+export type UpdatePartnerIntegrationDto = Partial<Omit<CreatePartnerIntegrationDto, 'providerCode' | 'organizationId'>>;
+/** List filters for the partnerships table. */
+export interface PartnerIntegrationQueryParams {
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    /** Super-Admin only. */
+    organizationId?: number;
+    providerCode?: PartnerProviderCode;
+    environment?: PartnerIntegrationEnvironment;
+    routingMode?: PartnerRoutingMode;
+    countryCode?: CountryCode;
+    enabled?: boolean;
+}

package/dist/types/modules/partner/interfaces/partner-provider.dto.d.ts

@@ -0,0 +1,70 @@
+import { PartnerIntegrationEnvironment, PartnerProviderCode, PartnerServiceCapability } from '../enums/partner-enums';
+/** A credential a partnership must supply, described by the backend adapter. */
+export interface PartnerProviderCredentialFieldDto {
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    /** Always true: a credential is supplied as a secret REFERENCE, never a value. */
+    secret: boolean;
+}
+/** A non-secret setting a partnership must (or may) supply for a provider. */
+export interface PartnerProviderConfigFieldDto {
+    key: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    type: 'string' | 'number' | 'boolean' | 'enum';
+    allowedValues?: string[];
+    defaultValue?: string | number | boolean;
+    maxLength?: number;
+}
+/**
+ * What one partner adapter can do, served by `GET /partner-services/providers`.
+ *
+ * The "add a partner" form is BUILT from these descriptors rather than
+ * hard-coded, so the fields the admin asks for can never drift from what the
+ * backend adapter actually needs. `available: false` marks a reserved partner
+ * that has no adapter yet - show it, but do not let anyone configure it.
+ */
+export interface PartnerProviderDescriptorDto {
+    providerCode: PartnerProviderCode;
+    name: string;
+    description: string;
+    capabilities: PartnerServiceCapability[];
+    defaultBaseUrls: Partial<Record<PartnerIntegrationEnvironment, string>>;
+    configFields: PartnerProviderConfigFieldDto[];
+    credentialFields: PartnerProviderCredentialFieldDto[];
+    supportsHealthCheck: boolean;
+    /**
+     * True when the partner publishes the state of a request already sent, so
+     * progress can be shown and a dispatch can move past SENT on its own.
+     */
+    supportsStatusPolling: boolean;
+    /**
+     * True when a request can be stood down after the partner accepted it.
+     *
+     * When false the admin must NOT offer a stand-down button: the honest answer
+     * is to telephone the partner, and a button that changed a status here while
+     * a crew kept driving would be worse than none.
+     */
+    supportsWithdrawal: boolean;
+    /** True when the details of a live request can be corrected. */
+    supportsAmendment: boolean;
+    /** True when the partner can be asked whether a request already exists. */
+    supportsDuplicateDetection: boolean;
+    available: boolean;
+}
+/** Result of the admin's "test connection" button. Never creates an emergency. */
+export interface PartnerConnectionTestResultDto {
+    integrationId: number;
+    status: string;
+    success: boolean;
+    /** True when the stored credential was accepted, even if health then failed. */
+    authenticated: boolean;
+    partnerServiceVersion?: string | null;
+    latencyMs: number;
+    checkedAt: string;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+}

package/dist/types/modules/partner/utils/partner-display.util.d.ts

@@ -0,0 +1,50 @@
+import { IncidentPartnerRoutingStatus, PartnerEngagementState, PartnerCoverageMatchType, PartnerDispatchStatus, PartnerIntegrationStatus, PartnerRoutingMode, PartnerServiceCapability } from '../enums/partner-enums';
+/**
+ * Human labels for the partner enums.
+ *
+ * Kept in the shared package rather than in the admin app so every screen that
+ * shows a dispatch - the list, the detail drawer, the incident view - names the
+ * same state the same way. An operator reading "Waiting for confirmation" in one
+ * place and "Pending approval" in another would reasonably assume they were
+ * different things.
+ */
+export declare const PARTNER_DISPATCH_STATUS_LABELS: Readonly<Record<PartnerDispatchStatus, string>>;
+/** How a partner's own progress state reads on screen. */
+export declare const PARTNER_ENGAGEMENT_STATE_LABELS: Readonly<Record<PartnerEngagementState, string>>;
+export declare const INCIDENT_PARTNER_ROUTING_STATUS_LABELS: Readonly<Record<IncidentPartnerRoutingStatus, string>>;
+export declare const PARTNER_ROUTING_MODE_LABELS: Readonly<Record<PartnerRoutingMode, string>>;
+export declare const PARTNER_INTEGRATION_STATUS_LABELS: Readonly<Record<PartnerIntegrationStatus, string>>;
+export declare const PARTNER_CAPABILITY_LABELS: Readonly<Record<PartnerServiceCapability, string>>;
+export declare const PARTNER_COVERAGE_MATCH_TYPE_LABELS: Readonly<Record<PartnerCoverageMatchType, string>>;
+/**
+ * Chip family for a dispatch status, matching the admin's existing chip
+ * vocabulary: `success` for anything the partner has, `warn` for anything still
+ * needing a human, `danger` for a failure, `neutral` for a settled non-event.
+ */
+export declare function partnerDispatchStatusTone(status: PartnerDispatchStatus): 'success' | 'warn' | 'danger' | 'neutral';
+/** The same tone mapping for the incident-level rolled-up status. */
+export declare function incidentPartnerRoutingTone(status: IncidentPartnerRoutingStatus): 'success' | 'warn' | 'danger' | 'neutral';
+/**
+ * Whether an operator can act on a dispatch, so a table can enable or hide its
+ * buttons without duplicating the backend's transition rules.
+ *
+ * The two withdrawals are separate answers: `canCancel` is a local decision
+ * before the partner has it, `canStandDown` means telling THEM - which is only
+ * possible for a partner whose API supports it.
+ */
+export declare function partnerDispatchActions(status: PartnerDispatchStatus, capabilities?: PartnerActionCapabilities): {
+    canApprove: boolean;
+    canReject: boolean;
+    canCancel: boolean;
+    canStandDown: boolean;
+    canAmend: boolean;
+    canResend: boolean;
+};
+/**
+ * What the partner behind a dispatch can actually do, taken from its provider
+ * descriptor. Passed in rather than assumed, because it differs per partner.
+ */
+export interface PartnerActionCapabilities {
+    supportsWithdrawal?: boolean;
+    supportsAmendment?: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarion-shared-types",
-  "version": "1.0.85",
+  "version": "1.0.87",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",