gdc-sdk-node-ts 0.9.1 → 0.12.0

package/dist/orchestration/organization-controller-sdk.d.ts

@@ -1,9 +1,11 @@
 import { type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
 import type { RouteContext } from '../individual-onboarding.js';
+import type { HostRouteContext, HostedTenantLifecycleInput } from '../host-onboarding.js';
 import type { EmployeeDeviceActivationResult, EmployeeDeviceActivationRequestInput } from '../device-activation.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
+import type { OrganizationLicenseOrderConfirmInput } from '../organization-license-order.js';
 import type { NodeCapability } from '../session.js';
-import type { OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput } from '../resource-operations.js';
+import type { LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput } from '../resource-operations.js';
 /**
  * Organization-controller oriented facade over a `NodeRuntimeClient`.
  *
@@ -29,6 +31,51 @@ export declare class OrganizationControllerSdk {
      * Preferred public alias for employee disable.
      */
     disableEmployee(ctx: RouteContext, input: OrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Searches employees/professionals under the current organization tenant.
+     */
+    searchOrganizationEmployees(ctx: RouteContext, input: OrganizationEmployeeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches organization-owned license seats using semantic license filters.
+     */
+    searchLicenses(ctx: RouteContext, input: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists organization-owned license seats with optional filters.
+     */
+    listLicenses(ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches commercial license offers known for the current organization.
+     */
+    searchLicenseOffers(ctx: RouteContext, input: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists commercial license offers known for the current organization.
+     */
+    listLicenseOffers(ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches commercial license orders/payment records known for the current
+     * organization.
+     */
+    searchLicenseOrders(ctx: RouteContext, input: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists commercial license orders/payment records known for the current
+     * organization.
+     */
+    listLicenseOrders(ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Confirms an already paid organization-side license order so GW CORE can
+     * activate additional tenant seats once the public route exists.
+     *
+     * The commercial/payment step happens outside GW CORE. This method models
+     * the follow-up confirmation that should materialize new seats from the
+     * accepted order.
+     *
+     * Current runtime note:
+     * - search/list of organization license offers and orders already exists
+     * - the public/write post-payment seat-activation route is not converged yet
+     * - current runtime clients therefore throw an explicit unsupported-flow
+     *   error instead of fabricating an unstable payload contract
+     */
+    confirmOrganizationLicenseOrder(ctx: RouteContext, input: OrganizationLicenseOrderConfirmInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
      * Purges an already inactive employee and frees the associated license seat.
      */
@@ -37,6 +84,16 @@ export declare class OrganizationControllerSdk {
      * Preferred public alias for employee purge.
      */
     purgeEmployee(ctx: RouteContext, input: OrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Disables the hosted tenant itself through the host registry once no active
+     * employees or individual/member descendants remain.
+     */
+    disableTenant(hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Purges the hosted tenant through the host registry after tenant disable and
+     * descendant purges have both completed.
+     */
+    purgeTenant(hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
      * Activates the employee device from a previously issued activation request.
      */

package/dist/orchestration/organization-controller-sdk.js

@@ -37,6 +37,67 @@ export class OrganizationControllerSdk {
         assertFacadeCapability(this.capabilities, ActorCapabilities.OrganizationDisableEmployee, ActorKinds.OrganizationController, 'disableEmployee');
         return requireClientMethod(this.client, 'disableEmployee')(ctx, input, pollOptions);
     }
+    /**
+     * Searches employees/professionals under the current organization tenant.
+     */
+    searchOrganizationEmployees(ctx, input) {
+        return requireClientMethod(this.client, 'searchOrganizationEmployees')(ctx, input);
+    }
+    /**
+     * Searches organization-owned license seats using semantic license filters.
+     */
+    searchLicenses(ctx, input) {
+        return requireClientMethod(this.client, 'searchOrganizationLicenses')(ctx, input);
+    }
+    /**
+     * Lists organization-owned license seats with optional filters.
+     */
+    listLicenses(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listOrganizationLicenses')(ctx, input);
+    }
+    /**
+     * Searches commercial license offers known for the current organization.
+     */
+    searchLicenseOffers(ctx, input) {
+        return requireClientMethod(this.client, 'searchOrganizationLicenseOffers')(ctx, input);
+    }
+    /**
+     * Lists commercial license offers known for the current organization.
+     */
+    listLicenseOffers(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listOrganizationLicenseOffers')(ctx, input);
+    }
+    /**
+     * Searches commercial license orders/payment records known for the current
+     * organization.
+     */
+    searchLicenseOrders(ctx, input) {
+        return requireClientMethod(this.client, 'searchOrganizationLicenseOrders')(ctx, input);
+    }
+    /**
+     * Lists commercial license orders/payment records known for the current
+     * organization.
+     */
+    listLicenseOrders(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listOrganizationLicenseOrders')(ctx, input);
+    }
+    /**
+     * Confirms an already paid organization-side license order so GW CORE can
+     * activate additional tenant seats once the public route exists.
+     *
+     * The commercial/payment step happens outside GW CORE. This method models
+     * the follow-up confirmation that should materialize new seats from the
+     * accepted order.
+     *
+     * Current runtime note:
+     * - search/list of organization license offers and orders already exists
+     * - the public/write post-payment seat-activation route is not converged yet
+     * - current runtime clients therefore throw an explicit unsupported-flow
+     *   error instead of fabricating an unstable payload contract
+     */
+    confirmOrganizationLicenseOrder(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'confirmOrganizationLicenseOrder')(ctx, input, pollOptions);
+    }
     /**
      * Purges an already inactive employee and frees the associated license seat.
      */
@@ -51,6 +112,22 @@ export class OrganizationControllerSdk {
         assertFacadeCapability(this.capabilities, ActorCapabilities.OrganizationPurgeEmployee, ActorKinds.OrganizationController, 'purgeEmployee');
         return requireClientMethod(this.client, 'purgeEmployee')(ctx, input, pollOptions);
     }
+    /**
+     * Disables the hosted tenant itself through the host registry once no active
+     * employees or individual/member descendants remain.
+     */
+    disableTenant(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.OrganizationDisableTenant, ActorKinds.OrganizationController, 'disableTenant');
+        return requireClientMethod(this.client, 'disableTenant')(hostCtx, input, pollOptions);
+    }
+    /**
+     * Purges the hosted tenant through the host registry after tenant disable and
+     * descendant purges have both completed.
+     */
+    purgeTenant(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.OrganizationPurgeTenant, ActorKinds.OrganizationController, 'purgeTenant');
+        return requireClientMethod(this.client, 'purgeTenant')(hostCtx, input, pollOptions);
+    }
     /**
      * Activates the employee device from a previously issued activation request.
      */

package/dist/orchestration/personal-sdk.d.ts

@@ -1,7 +1,7 @@
 import { type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
 import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from '../individual-start.js';
 import type { RouteContext } from '../individual-onboarding.js';
-import type { CommunicationIngestionInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IpsOrFhirImportInput } from '../resource-operations.js';
+import type { ClinicalBundleSearchInput, CommunicationIngestionInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IpsOrFhirImportInput, LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput } from '../resource-operations.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
 export declare class PersonalSdk {
     private readonly client;
@@ -16,6 +16,22 @@ export declare class PersonalSdk {
     ingestCommunicationAndUpdateIndex(ctx: RouteContext, input: CommunicationIngestionInput): Promise<SubmitAndPollResult>;
     /** Triggers digital twin generation from subject data. */
     generateDigitalTwinFromSubjectData(ctx: RouteContext, input: DigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    /** Searches indexed clinical bundles for the current subject/controller context. */
+    searchClinicalBundle(ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /** Returns the latest IPS-oriented bundle for one subject. */
+    getLatestIps(ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
+    /** Searches subject-side license seats using semantic filters. */
+    searchLicenses(ctx: RouteContext, input: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /** Lists subject-side license seats with optional filters. */
+    listLicenses(ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /** Searches subject-side commercial license offers. */
+    searchLicenseOffers(ctx: RouteContext, input: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /** Lists subject-side commercial license offers. */
+    listLicenseOffers(ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /** Searches subject-side commercial license orders/payment projections. */
+    searchLicenseOrders(ctx: RouteContext, input: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /** Lists subject-side commercial license orders/payment projections. */
+    listLicenseOrders(ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
     /** Requests SMART/OpenID token with simplified exchange flow. */
     requestSmartToken(input: SmartTokenRequestInput): Promise<SmartTokenExchangeResult>;
     submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;

package/dist/orchestration/personal-sdk.js

@@ -24,6 +24,38 @@ export class PersonalSdk {
     generateDigitalTwinFromSubjectData(ctx, input) {
         return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
     }
+    /** Searches indexed clinical bundles for the current subject/controller context. */
+    searchClinicalBundle(ctx, input) {
+        return requireClientMethod(this.client, 'searchClinicalBundle')(ctx, input);
+    }
+    /** Returns the latest IPS-oriented bundle for one subject. */
+    getLatestIps(ctx, input) {
+        return requireClientMethod(this.client, 'getLatestIps')(ctx, input);
+    }
+    /** Searches subject-side license seats using semantic filters. */
+    searchLicenses(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenses')(ctx, input);
+    }
+    /** Lists subject-side license seats with optional filters. */
+    listLicenses(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenses')(ctx, input);
+    }
+    /** Searches subject-side commercial license offers. */
+    searchLicenseOffers(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenseOffers')(ctx, input);
+    }
+    /** Lists subject-side commercial license offers. */
+    listLicenseOffers(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenseOffers')(ctx, input);
+    }
+    /** Searches subject-side commercial license orders/payment projections. */
+    searchLicenseOrders(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenseOrders')(ctx, input);
+    }
+    /** Lists subject-side commercial license orders/payment projections. */
+    listLicenseOrders(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenseOrders')(ctx, input);
+    }
     /** Requests SMART/OpenID token with simplified exchange flow. */
     requestSmartToken(input) {
         return requireClientMethod(this.client, 'requestSmartToken')(input);

package/dist/order-offer-summary.d.ts

@@ -0,0 +1,6 @@
+import { type LicenseOfferPreview, type LicenseOrderSummary } from 'gdc-common-utils-ts';
+export type OfferPreview = LicenseOfferPreview;
+export type OrderSummary = LicenseOrderSummary;
+export declare function extractOfferIdFromResponseBody(body: unknown): string | undefined;
+export declare function extractOfferPreviewFromResponseBody(body: unknown): OfferPreview;
+export declare function extractOrderSummaryFromResponseBody(body: unknown): OrderSummary;

package/dist/order-offer-summary.js

@@ -0,0 +1,11 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ClaimsOfferSchemaorg, extractPrimaryClaims, readLicenseOfferPreviewFromResponseBody, readLicenseOrderSummaryFromResponseBody, } from 'gdc-common-utils-ts';
+export function extractOfferIdFromResponseBody(body) {
+    return String(extractPrimaryClaims(body)[ClaimsOfferSchemaorg.identifier] || '').trim() || undefined;
+}
+export function extractOfferPreviewFromResponseBody(body) {
+    return readLicenseOfferPreviewFromResponseBody(body);
+}
+export function extractOrderSummaryFromResponseBody(body) {
+    return readLicenseOrderSummaryFromResponseBody(body);
+}

package/dist/organization-license-order.d.ts

@@ -0,0 +1,40 @@
+import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
+import type { HostRouteContext } from './host-onboarding.js';
+import type { RouteContext } from './individual-onboarding.js';
+/**
+ * High-level runtime input for organization-side extra-license activation after
+ * the portal has already resolved the commercial/payment step out of band.
+ *
+ * Target business sequence:
+ * - portal lists/searches `Offer`
+ * - portal completes the fictitious or real payment outside GW CORE
+ * - portal confirms the accepted offer to GW CORE
+ * - GW CORE materializes the new `device-licenses` seats for the tenant
+ *
+ * Transport note:
+ * - current GW CORE exposes this confirmation step through the host
+ *   `registry/org.schema/Order/_batch` route
+ * - the organization controller still reasons in tenant context, so the
+ *   runtime adapts that higher-level intent onto the current host route
+ */
+export type OrganizationLicenseOrderConfirmInput = Readonly<{
+    offerId: string;
+    hostNetwork?: string;
+    dataType?: string;
+    additionalClaims?: Record<string, unknown>;
+    timeoutSeconds?: number;
+    intervalSeconds?: number;
+}>;
+type ConfirmOrganizationLicenseOrderDeps = Readonly<{
+    routeCtx: RouteContext;
+    input: OrganizationLicenseOrderConfirmInput;
+    defaultTimeoutMs?: number;
+    defaultIntervalMs?: number;
+    hostRegistryOrderBatchPath: (ctx: HostRouteContext) => string;
+    hostRegistryOrderPollPath: (ctx: HostRouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
+}>;
+export declare function confirmOrganizationLicenseOrderWithDeps(deps: ConfirmOrganizationLicenseOrderDeps): Promise<SubmitAndPollResult>;
+export {};

package/dist/organization-license-order.js

@@ -0,0 +1,42 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { resolvePollOptionsFromSeconds } from './poll-options.js';
+export async function confirmOrganizationLicenseOrderWithDeps(deps) {
+    const offerId = String(deps.input.offerId || '').trim();
+    if (!offerId) {
+        throw new Error('confirmOrganizationLicenseOrder requires offerId.');
+    }
+    const claims = {
+        '@context': 'org.schema',
+        'Order.acceptedOffer.identifier': offerId,
+        ...(deps.input.additionalClaims || {}),
+    };
+    const hostCtx = {
+        jurisdiction: String(deps.routeCtx.jurisdiction || '').trim(),
+        hostNetwork: String(deps.input.hostNetwork || 'test').trim() || 'test',
+    };
+    const payload = {
+        jti: `jti-${createRuntimeUuid()}`,
+        iss: deps.routeCtx.tenantId,
+        aud: deps.routeCtx.tenantId,
+        type: 'application/didcomm-plain+json',
+        thid: `organization-license-order-${createRuntimeUuid()}`,
+        body: {
+            data: [{
+                    type: deps.input.dataType || 'Organization-order-request-v1.0',
+                    meta: { claims },
+                    resource: { meta: { claims } },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.hostRegistryOrderBatchPath(hostCtx), deps.hostRegistryOrderPollPath(hostCtx), payload, resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
+        timeoutMs: deps.defaultTimeoutMs,
+        intervalMs: deps.defaultIntervalMs,
+    }));
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/resource-operations.d.ts

@@ -1,3 +1,4 @@
+import { type LicenseOfferSearchDraft, type LicenseOrderSearchDraft, type LicenseListSearchDraft } from 'gdc-common-utils-ts';
 import type { BundleSearchQuery, CommunicationInput, DateRange, EmployeeSearchValue } from 'gdc-sdk-core-ts';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
 import type { RouteContext } from './individual-onboarding.js';
@@ -59,6 +60,43 @@ export type OrganizationEmployeeSearchInput = {
         intervalMs?: number;
     };
 };
+/**
+ * Runtime search/list input for license seats exposed through actor facades.
+ *
+ * The semantic filter set comes from the shared license controller facade.
+ */
+export type LicenseListRuntimeSearchInput = {
+    licenseQuery?: Partial<LicenseListSearchDraft>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/**
+ * Runtime search/list input for commercial offer read-models exposed through
+ * actor facades.
+ */
+export type LicenseOfferRuntimeSearchInput = {
+    offerQuery?: Partial<LicenseOfferSearchDraft>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/**
+ * Runtime search/list input for commercial order/payment read-models exposed
+ * through actor facades.
+ */
+export type LicenseOrderRuntimeSearchInput = {
+    orderQuery?: Partial<LicenseOrderSearchDraft>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
 /**
  * Current GW CORE individual/family lifecycle locator payload.
  *
@@ -255,6 +293,54 @@ export declare function searchOrganizationEmployeesWithDeps(routeCtx: RouteConte
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Searches license seats for one organization/tenant through `License/_search`.
+ */
+export declare function searchOrganizationLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput, deps: {
+    organizationLicenseSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+/**
+ * Lists license seats using the same canonical `License/_search` route with no
+ * mandatory filters.
+ */
+export declare function listOrganizationLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicensesWithDeps>[2]): Promise<SubmitAndPollResult>;
+/**
+ * Searches commercial license offers for one organization/tenant through
+ * `Offer/_search`.
+ */
+export declare function searchOrganizationLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput, deps: {
+    organizationLicenseOfferSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseOfferSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listOrganizationLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicenseOffersWithDeps>[2]): Promise<SubmitAndPollResult>;
+/**
+ * Searches commercial license orders/payment projections for one
+ * organization/tenant through `Order/_search`.
+ */
+export declare function searchOrganizationLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput, deps: {
+    organizationLicenseOrderSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseOrderSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listOrganizationLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicenseOrdersWithDeps>[2]): Promise<SubmitAndPollResult>;
 export declare function disableIndividualOrganizationWithDeps(routeCtx: RouteContext, input: IndividualOrganizationLifecycleInput, options: {
     timeoutMs?: number;
     intervalMs?: number;
@@ -281,6 +367,47 @@ export declare function purgeIndividualOrganizationWithDeps(routeCtx: RouteConte
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Searches license seats for one individual/family controller context through
+ * the shared `License/_search` route.
+ */
+export declare function searchIndividualLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput, deps: {
+    individualLicenseSearchPath: (ctx: RouteContext) => string;
+    individualLicenseSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+/**
+ * Lists license seats for the individual/family side using the same canonical
+ * search route without mandatory filters.
+ */
+export declare function listIndividualLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicensesWithDeps>[2]): Promise<SubmitAndPollResult>;
+export declare function searchIndividualLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput, deps: {
+    individualLicenseOfferSearchPath: (ctx: RouteContext) => string;
+    individualLicenseOfferSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listIndividualLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicenseOffersWithDeps>[2]): Promise<SubmitAndPollResult>;
+export declare function searchIndividualLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput, deps: {
+    individualLicenseOrderSearchPath: (ctx: RouteContext) => string;
+    individualLicenseOrderSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listIndividualLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicenseOrdersWithDeps>[2]): Promise<SubmitAndPollResult>;
 export declare function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx: RouteContext, input: IpsOrFhirImportInput, deps: {
     individualCompositionR4BatchPath: (ctx: RouteContext) => string;
     individualCompositionR4PollPath: (ctx: RouteContext) => string;
@@ -291,6 +418,32 @@ export declare function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx: RouteCon
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function disableIndividualMemberWithDeps(routeCtx: RouteContext, input: IndividualMemberLifecycleInput, options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+} | undefined, deps: {
+    individualRelatedPersonBatchPath: (ctx: RouteContext) => string;
+    individualRelatedPersonPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function purgeIndividualMemberWithDeps(routeCtx: RouteContext, input: IndividualMemberLifecycleInput, options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+} | undefined, deps: {
+    individualRelatedPersonPurgePath: (ctx: RouteContext) => string;
+    individualRelatedPersonPurgePollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
 export declare function upsertRelatedPersonAndPollWithDeps(routeCtx: RouteContext, input: RelatedPersonUpsertInput, deps: {
     individualRelatedPersonBatchPath: (ctx: RouteContext) => string;
     individualRelatedPersonPollPath: (ctx: RouteContext) => string;