gdc-common-utils-ts 1.24.1 → 2.0.1

package/dist/utils/jwk-thumbprint.js

@@ -0,0 +1,57 @@
+import { createHash } from 'node:crypto';
+import { UrnPrefixes } from '../constants/urn.js';
+function canonicalizeForThumbprint(jwk) {
+    const keys = Object.keys(jwk).sort();
+    const parts = keys.map((key) => `"${key}":${JSON.stringify(jwk[key])}`);
+    return `{${parts.join(',')}}`;
+}
+function toBaseThumbprintJwk(jwk) {
+    if (jwk.kty === 'EC') {
+        const { crv, x, y } = jwk;
+        if (!crv || !x || !y)
+            throw new Error('EC JWK thumbprint requires crv, x and y.');
+        return { kty: 'EC', crv, x, y };
+    }
+    if (jwk.kty === 'RSA') {
+        const { e, n } = jwk;
+        if (!e || !n)
+            throw new Error('RSA JWK thumbprint requires e and n.');
+        return { kty: 'RSA', e, n };
+    }
+    if (jwk.kty === 'OKP') {
+        const { crv, x } = jwk;
+        if (!crv || !x)
+            throw new Error('OKP JWK thumbprint requires crv and x.');
+        return { kty: 'OKP', crv, x };
+    }
+    if (jwk.kty === 'AKP') {
+        const { alg, pub } = jwk;
+        if (!alg || !pub)
+            throw new Error('AKP JWK thumbprint requires alg and pub.');
+        return { kty: 'AKP', alg, pub };
+    }
+    throw new Error(`Unsupported JWK kty for RFC7638 thumbprint: ${jwk.kty || 'unknown'}`);
+}
+/**
+ * Computes the RFC 7638 JWK thumbprint as a bare base64url string.
+ *
+ * Canonical fields per supported key family:
+ * - `EC`: `kty`, `crv`, `x`, `y`
+ * - `RSA`: `kty`, `e`, `n`
+ * - `OKP`: `kty`, `crv`, `x`
+ * - `AKP` / ML-DSA: `kty`, `alg`, `pub`
+ *
+ * For classical EC keys, the curve is taken from `crv`, so keys such as
+ * `secp256k1` are handled naturally through `crv: 'secp256k1'`.
+ */
+export function computeRfc7638JwkThumbprint(jwk) {
+    const canonical = canonicalizeForThumbprint(toBaseThumbprintJwk(jwk));
+    return createHash('sha256').update(canonical).digest('base64url');
+}
+/**
+ * Returns the RFC 9278 thumbprint URI form:
+ * `urn:ietf:params:oauth:jwk-thumbprint:sha-256:<base64url>`
+ */
+export function toJwkThumbprintSha256Urn(jwk) {
+    return `${UrnPrefixes.JwkThumbprintSha256KeyId}${computeRfc7638JwkThumbprint(jwk)}`;
+}

package/dist/utils/legal-organization-onboarding.d.ts

@@ -0,0 +1,97 @@
+import { ClaimsOrganizationSchemaorg } from '../constants/schemaorg';
+import { ClaimsRecord } from '../models/resource-document';
+export type LegalOrganizationOnboardingErrorCode = 'MISSING_IDENTIFIER_OR_TAX_ID' | 'EXPLICIT_ALTERNATE_NAME_NOT_ALLOWED';
+export type LegalOrganizationOnboardingValidationError = {
+    code: LegalOrganizationOnboardingErrorCode;
+    message: string;
+    claimPaths: string[];
+};
+export type ValidateLegalOrganizationOnboardingClaimsOptions = {
+    /**
+     * When `false` (default), `alternateName` is treated as a compatibility alias
+     * derived from the canonical legal identifier. Callers may still send an
+     * explicit value, but it must match the final normalized
+     * `Organization.identifier.value`.
+     *
+     * When `true`, callers may keep an explicit `alternateName` that differs from
+     * `Organization.identifier.value`.
+     */
+    allowExplicitAlternateNameForTenantId?: boolean;
+};
+export type ValidateLegalOrganizationOnboardingClaimsResult = {
+    ok: boolean;
+    errors: LegalOrganizationOnboardingValidationError[];
+    missingClaims: string[];
+    normalizedClaims: ClaimsRecord;
+    derived: {
+        identifierValueFromTaxId: boolean;
+        alternateNameFromIdentifierValue: boolean;
+    };
+};
+/**
+ * JSON Schema for legal-organization onboarding claims used by high-level SDK
+ * forms and assistants before they submit anything to GW CORE.
+ *
+ * Contract:
+ * - one of `Organization.identifier.value` or `Organization.taxID` must be
+ *   provided
+ * - `alternateName` is optional at input time because current GW compatibility
+ *   may derive it from the canonical legal identifier
+ * - callers that want stricter tenant-alias behavior must still run the
+ *   validator below because JSON Schema alone cannot express the
+ *   runtime option `allowExplicitAlternateNameForTenantId`
+ */
+export declare const LEGAL_ORGANIZATION_ONBOARDING_JSON_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://gdc/common-utils/legal-organization-onboarding.schema.json";
+    readonly title: "Legal Organization Onboarding Claims";
+    readonly type: "object";
+    readonly properties: {
+        readonly '@context': {
+            readonly type: "string";
+            readonly enum: readonly ["org.schema"];
+        };
+        readonly "org.schema.Organization.identifier.value": {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Canonical legal identifier used by onboarding and tenant normalization.";
+        };
+        readonly "org.schema.Organization.taxID": {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Compatibility tax identifier that may backfill Organization.identifier.value.";
+        };
+        readonly "org.schema.Organization.alternateName": {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Optional compatibility alias. If omitted, callers may derive it from Organization.identifier.value.";
+        };
+    };
+    readonly oneOf: readonly [{
+        readonly required: readonly [ClaimsOrganizationSchemaorg.identifierValue];
+    }, {
+        readonly required: readonly [ClaimsOrganizationSchemaorg.taxId];
+    }];
+    readonly additionalProperties: true;
+};
+/**
+ * Validates and normalizes legal-organization onboarding claims for SDKs,
+ * forms, and assistant-style data collection flows.
+ *
+ * Main behavior:
+ * - requires at least one of `Organization.identifier.value` or
+ *   `Organization.taxID`
+ * - if `identifier.value` is missing and `taxID` exists, copies
+ *   `taxID -> identifier.value`
+ * - if `alternateName` is missing and a canonical identifier exists, copies
+ *   `identifier.value -> alternateName`
+ * - when `allowExplicitAlternateNameForTenantId` is `false` (default),
+ *   rejects explicit `alternateName` values that differ from the final
+ *   canonical `identifier.value`
+ *
+ * The result shape is intentionally assistant-friendly:
+ * - `missingClaims` tells UI/voice flows what is still required
+ * - `normalizedClaims` shows the post-derivation claim set
+ * - `derived` explains which values were filled automatically
+ */
+export declare function validateLegalOrganizationOnboardingClaims(claims: ClaimsRecord, options?: ValidateLegalOrganizationOnboardingClaimsOptions): ValidateLegalOrganizationOnboardingClaimsResult;

package/dist/utils/legal-organization-onboarding.js

@@ -0,0 +1,128 @@
+import { ClaimsOrganizationSchemaorg } from '../constants/schemaorg.js';
+/**
+ * JSON Schema for legal-organization onboarding claims used by high-level SDK
+ * forms and assistants before they submit anything to GW CORE.
+ *
+ * Contract:
+ * - one of `Organization.identifier.value` or `Organization.taxID` must be
+ *   provided
+ * - `alternateName` is optional at input time because current GW compatibility
+ *   may derive it from the canonical legal identifier
+ * - callers that want stricter tenant-alias behavior must still run the
+ *   validator below because JSON Schema alone cannot express the
+ *   runtime option `allowExplicitAlternateNameForTenantId`
+ */
+export const LEGAL_ORGANIZATION_ONBOARDING_JSON_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://gdc/common-utils/legal-organization-onboarding.schema.json',
+    title: 'Legal Organization Onboarding Claims',
+    type: 'object',
+    properties: {
+        '@context': {
+            type: 'string',
+            enum: ['org.schema'],
+        },
+        [ClaimsOrganizationSchemaorg.identifierValue]: {
+            type: 'string',
+            minLength: 1,
+            description: 'Canonical legal identifier used by onboarding and tenant normalization.',
+        },
+        [ClaimsOrganizationSchemaorg.taxId]: {
+            type: 'string',
+            minLength: 1,
+            description: 'Compatibility tax identifier that may backfill Organization.identifier.value.',
+        },
+        [ClaimsOrganizationSchemaorg.alternateName]: {
+            type: 'string',
+            minLength: 1,
+            description: 'Optional compatibility alias. If omitted, callers may derive it from Organization.identifier.value.',
+        },
+    },
+    oneOf: [
+        { required: [ClaimsOrganizationSchemaorg.identifierValue] },
+        { required: [ClaimsOrganizationSchemaorg.taxId] },
+    ],
+    additionalProperties: true,
+};
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+/**
+ * Validates and normalizes legal-organization onboarding claims for SDKs,
+ * forms, and assistant-style data collection flows.
+ *
+ * Main behavior:
+ * - requires at least one of `Organization.identifier.value` or
+ *   `Organization.taxID`
+ * - if `identifier.value` is missing and `taxID` exists, copies
+ *   `taxID -> identifier.value`
+ * - if `alternateName` is missing and a canonical identifier exists, copies
+ *   `identifier.value -> alternateName`
+ * - when `allowExplicitAlternateNameForTenantId` is `false` (default),
+ *   rejects explicit `alternateName` values that differ from the final
+ *   canonical `identifier.value`
+ *
+ * The result shape is intentionally assistant-friendly:
+ * - `missingClaims` tells UI/voice flows what is still required
+ * - `normalizedClaims` shows the post-derivation claim set
+ * - `derived` explains which values were filled automatically
+ */
+export function validateLegalOrganizationOnboardingClaims(claims, options = {}) {
+    const normalizedClaims = { ...(claims || {}) };
+    const errors = [];
+    const missingClaims = [];
+    const allowExplicitAlternateNameForTenantId = options.allowExplicitAlternateNameForTenantId === true;
+    const identifierValue = normalizeOptionalString(normalizedClaims[ClaimsOrganizationSchemaorg.identifierValue]);
+    const taxId = normalizeOptionalString(normalizedClaims[ClaimsOrganizationSchemaorg.taxId]);
+    const explicitAlternateName = normalizeOptionalString(normalizedClaims[ClaimsOrganizationSchemaorg.alternateName]);
+    let finalIdentifierValue = identifierValue;
+    let identifierValueFromTaxId = false;
+    let alternateNameFromIdentifierValue = false;
+    if (!finalIdentifierValue && taxId) {
+        finalIdentifierValue = taxId;
+        normalizedClaims[ClaimsOrganizationSchemaorg.identifierValue] = taxId;
+        identifierValueFromTaxId = true;
+    }
+    if (!finalIdentifierValue) {
+        missingClaims.push(ClaimsOrganizationSchemaorg.identifierValue, ClaimsOrganizationSchemaorg.taxId);
+        errors.push({
+            code: 'MISSING_IDENTIFIER_OR_TAX_ID',
+            message: 'Legal organization onboarding requires Organization.identifier.value or Organization.taxID.',
+            claimPaths: [
+                ClaimsOrganizationSchemaorg.identifierValue,
+                ClaimsOrganizationSchemaorg.taxId,
+            ],
+        });
+    }
+    if (!explicitAlternateName && finalIdentifierValue) {
+        normalizedClaims[ClaimsOrganizationSchemaorg.alternateName] = finalIdentifierValue;
+        alternateNameFromIdentifierValue = true;
+    }
+    if (explicitAlternateName
+        && finalIdentifierValue
+        && !allowExplicitAlternateNameForTenantId
+        && explicitAlternateName !== finalIdentifierValue) {
+        errors.push({
+            code: 'EXPLICIT_ALTERNATE_NAME_NOT_ALLOWED',
+            message: 'Explicit Organization.alternateName is not allowed unless it matches Organization.identifier.value or the caller enables allowExplicitAlternateNameForTenantId.',
+            claimPaths: [
+                ClaimsOrganizationSchemaorg.alternateName,
+                ClaimsOrganizationSchemaorg.identifierValue,
+            ],
+        });
+    }
+    return {
+        ok: errors.length === 0,
+        errors,
+        missingClaims,
+        normalizedClaims,
+        derived: {
+            identifierValueFromTaxId,
+            alternateNameFromIdentifierValue,
+        },
+    };
+}

package/dist/utils/license-commercial-search.d.ts

@@ -8,14 +8,14 @@ export declare const LicenseCommercialSearchOperation: Readonly<{
     readonly Offer: "Offer:Search";
     readonly Order: "Order:Search";
 }>;
-export type LicenseOfferSearchDraft = Readonly<{
+export type LicenseOfferSearchState = Readonly<{
     offerId?: string;
     status?: string;
     category?: string;
     customerType?: string;
     additionalClaims: LicenseClaims;
 }>;
-export type LicenseOrderSearchDraft = Readonly<{
+export type LicenseOrderSearchState = Readonly<{
     acceptedOfferId?: string;
     invoiceId?: string;
     paymentMethod?: string;
@@ -43,13 +43,13 @@ export type LicenseOrderRecord = Readonly<{
  */
 export declare class LicenseOfferSearchEditor {
     private draft;
-    constructor(initial?: Partial<LicenseOfferSearchDraft>);
+    constructor(initial?: Partial<LicenseOfferSearchState>);
     setOfferId(value: string): this;
     setStatus(value: string): this;
     setCategory(value: string): this;
     setCustomerType(value: string): this;
     mergeClaims(claims: LicenseClaims): this;
-    getDraft(): LicenseOfferSearchDraft;
+    getState(): LicenseOfferSearchState;
     buildSearchEntry(): {
         type: string;
         request: {
@@ -72,13 +72,13 @@ export declare class LicenseOfferSearchEditor {
  */
 export declare class LicenseOrderSearchEditor {
     private draft;
-    constructor(initial?: Partial<LicenseOrderSearchDraft>);
+    constructor(initial?: Partial<LicenseOrderSearchState>);
     setAcceptedOfferId(value: string): this;
     setInvoiceId(value: string): this;
     setPaymentMethod(value: string): this;
     setStatus(value: string): this;
     mergeClaims(claims: LicenseClaims): this;
-    getDraft(): LicenseOrderSearchDraft;
+    getState(): LicenseOrderSearchState;
     buildSearchEntry(): {
         type: string;
         request: {

package/dist/utils/license-commercial-search.js

@@ -68,7 +68,7 @@ export class LicenseOfferSearchEditor {
         });
         return this;
     }
-    getDraft() {
+    getState() {
         return cloneOfferSearchDraft(this.draft);
     }
     buildSearchEntry() {
@@ -131,7 +131,7 @@ export class LicenseOrderSearchEditor {
         });
         return this;
     }
-    getDraft() {
+    getState() {
         return cloneOrderSearchDraft(this.draft);
     }
     buildSearchEntry() {

package/dist/utils/license-list-search.d.ts

@@ -1,11 +1,11 @@
 import { buildLicenseSearchEntry, type LicenseClaims, type LicenseSearchInput, type LicenseStatus } from './license';
 /**
- * High-level filter draft for license list/search screens.
+ * High-level filter state for license list/search screens.
  *
- * This draft keeps UI semantics stable even when the runtime search transport
+ * This state keeps UI semantics stable even when the runtime search transport
  * still supports only a subset of the final portal-facing filters.
  */
-export type LicenseListSearchDraft = Readonly<{
+export type LicenseListSearchState = Readonly<{
     serialNumbers?: readonly string[];
     email?: string;
     role?: string;
@@ -49,18 +49,18 @@ export type LicenseListSummary = Readonly<{
     inactive: number;
 }>;
 /**
- * High-level chainable draft for frontend/backend license list/search filters.
+ * High-level chainable editor state for frontend/backend license list/search filters.
  *
  * Intent:
  * - keep UI-level filters (`active`, `unused`, `assigned`, `period`) visible at
  *   the semantic layer
  * - map the currently supported subset to the existing canonical search entry
- * - preserve the rest in a neutral draft until the final backend facade is
+ * - preserve the rest in a neutral state until the final backend facade is
  *   fully converged
  */
 export declare class LicenseListSearchEditor {
     private draft;
-    constructor(initial?: Partial<LicenseListSearchDraft>);
+    constructor(initial?: Partial<LicenseListSearchState>);
     setSerialNumbers(values: readonly string[]): this;
     setEmail(value: string): this;
     setRole(value: string): this;
@@ -73,7 +73,7 @@ export declare class LicenseListSearchEditor {
     setUnused(value: boolean): this;
     setPeriod(start?: string, end?: string): this;
     mergeClaims(claims: LicenseClaims): this;
-    getDraft(): LicenseListSearchDraft;
+    getState(): LicenseListSearchState;
     /**
      * Returns the currently supported runtime-facing search input subset.
      */

package/dist/utils/license-list-search.js

@@ -8,42 +8,42 @@ function normalizeText(value) {
 function cloneClaims(claims) {
     return { ...(claims || {}) };
 }
-function cloneDraft(draft) {
+function cloneDraft(state) {
     return {
-        serialNumbers: Array.isArray(draft?.serialNumbers) ? [...draft.serialNumbers] : undefined,
-        email: normalizeText(draft?.email),
-        role: normalizeText(draft?.role),
-        status: draft?.status,
-        subjectId: normalizeText(draft?.subjectId),
-        userClass: normalizeText(draft?.userClass),
-        type: normalizeText(draft?.type),
-        active: typeof draft?.active === 'boolean' ? draft.active : undefined,
-        assigned: typeof draft?.assigned === 'boolean' ? draft.assigned : undefined,
-        unused: typeof draft?.unused === 'boolean' ? draft.unused : undefined,
-        periodStart: normalizeText(draft?.periodStart),
-        periodEnd: normalizeText(draft?.periodEnd),
-        additionalClaims: cloneClaims(draft?.additionalClaims),
+        serialNumbers: Array.isArray(state?.serialNumbers) ? [...state.serialNumbers] : undefined,
+        email: normalizeText(state?.email),
+        role: normalizeText(state?.role),
+        status: state?.status,
+        subjectId: normalizeText(state?.subjectId),
+        userClass: normalizeText(state?.userClass),
+        type: normalizeText(state?.type),
+        active: typeof state?.active === 'boolean' ? state.active : undefined,
+        assigned: typeof state?.assigned === 'boolean' ? state.assigned : undefined,
+        unused: typeof state?.unused === 'boolean' ? state.unused : undefined,
+        periodStart: normalizeText(state?.periodStart),
+        periodEnd: normalizeText(state?.periodEnd),
+        additionalClaims: cloneClaims(state?.additionalClaims),
     };
 }
-function resolveStatus(draft) {
-    if (draft.status)
-        return draft.status;
-    if (draft.active === true)
+function resolveStatus(state) {
+    if (state.status)
+        return state.status;
+    if (state.active === true)
         return LicenseStatuses.Active;
-    if (draft.active === false)
+    if (state.active === false)
         return LicenseStatuses.Inactive;
-    if (draft.unused === true)
+    if (state.unused === true)
         return LicenseStatuses.Available;
     return undefined;
 }
 /**
- * High-level chainable draft for frontend/backend license list/search filters.
+ * High-level chainable editor state for frontend/backend license list/search filters.
  *
  * Intent:
  * - keep UI-level filters (`active`, `unused`, `assigned`, `period`) visible at
  *   the semantic layer
  * - map the currently supported subset to the existing canonical search entry
- * - preserve the rest in a neutral draft until the final backend facade is
+ * - preserve the rest in a neutral state until the final backend facade is
  *   fully converged
  */
 export class LicenseListSearchEditor {
@@ -102,7 +102,7 @@ export class LicenseListSearchEditor {
         });
         return this;
     }
-    getDraft() {
+    getState() {
         return cloneDraft(this.draft);
     }
     /**

package/dist/utils/license-offer-order.d.ts

@@ -19,7 +19,7 @@ export type LicenseOrderSummary = Readonly<{
     currency?: string;
     seats?: number;
 }>;
-export type LicenseOfferOrderDraft = Readonly<{
+export type LicenseOfferOrderState = Readonly<{
     offer: LicenseOfferPreview;
     order: LicenseOrderSummary;
     baseClaims: LicenseClaims;
@@ -32,25 +32,25 @@ export type LicenseOfferOrderDraft = Readonly<{
  * serialization without keeping mutable editor state.
  */
 export interface LicenseOfferOrderFacade {
-    createDraft(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderDraft;
-    setOfferId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setAmount(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setCurrency(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setSeats(draft: LicenseOfferOrderDraft, value: number): LicenseOfferOrderDraft;
-    setPlanName(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setSku(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setPaymentMethod(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setCheckoutUrl(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setAcceptedOfferId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setPaymentUrl(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setInvoiceId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setActivationCode(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setBaseClaims(draft: LicenseOfferOrderDraft, claims: LicenseClaims): LicenseOfferOrderDraft;
-    buildOfferClaims(draft: LicenseOfferOrderDraft): LicenseClaims;
-    buildOrderClaims(draft: LicenseOfferOrderDraft): LicenseClaims;
+    createState(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderState;
+    setOfferId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setAmount(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setCurrency(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setSeats(state: LicenseOfferOrderState, value: number): LicenseOfferOrderState;
+    setPlanName(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setSku(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setPaymentMethod(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setCheckoutUrl(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setAcceptedOfferId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setPaymentUrl(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setInvoiceId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setActivationCode(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setBaseClaims(state: LicenseOfferOrderState, claims: LicenseClaims): LicenseOfferOrderState;
+    buildOfferClaims(state: LicenseOfferOrderState): LicenseClaims;
+    buildOrderClaims(state: LicenseOfferOrderState): LicenseClaims;
     readOfferPreviewFromResponseBody(body: unknown): LicenseOfferPreview;
     readOrderSummaryFromResponseBody(body: unknown): LicenseOrderSummary;
-    createEditor(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderEditor;
+    createEditor(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderEditor;
 }
 /**
  * Chainable editor mirroring the didactic `get/set/build/read` style used by
@@ -104,4 +104,4 @@ export declare function createLicenseOfferOrderFacade(): LicenseOfferOrderFacade
 /**
  * Creates the chainable editor shown in the 101 tests.
  */
-export declare function createLicenseOfferOrderEditor(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderEditor;
+export declare function createLicenseOfferOrderEditor(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderEditor;