@xrmforge/typegen 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1295 @@
+import { TokenCredential } from '@azure/identity';
+
+/**
+ * @xrmforge/typegen - Error Types
+ *
+ * Centralized error hierarchy for consistent error handling across the framework.
+ * Every error carries a machine-readable code, a human-readable message,
+ * and optional context for debugging.
+ */
+declare enum ErrorCode {
+    AUTH_MISSING_CONFIG = "AUTH_1001",
+    AUTH_INVALID_CREDENTIALS = "AUTH_1002",
+    AUTH_TOKEN_FAILED = "AUTH_1003",
+    AUTH_TOKEN_EXPIRED = "AUTH_1004",
+    API_REQUEST_FAILED = "API_2001",
+    API_RATE_LIMITED = "API_2002",
+    API_NOT_FOUND = "API_2003",
+    API_UNAUTHORIZED = "API_2004",
+    API_TIMEOUT = "API_2005",
+    META_ENTITY_NOT_FOUND = "META_3001",
+    META_SOLUTION_NOT_FOUND = "META_3002",
+    META_FORM_PARSE_FAILED = "META_3003",
+    META_ATTRIBUTE_UNKNOWN_TYPE = "META_3004",
+    GEN_OUTPUT_WRITE_FAILED = "GEN_4001",
+    GEN_TEMPLATE_FAILED = "GEN_4002",
+    GEN_INVALID_IDENTIFIER = "GEN_4003",
+    CONFIG_INVALID = "CONFIG_5001",
+    CONFIG_FILE_NOT_FOUND = "CONFIG_5002",
+    CONFIG_ENV_VAR_MISSING = "CONFIG_5003"
+}
+/**
+ * Base error class for all XrmForge errors.
+ * Carries a structured error code and optional context object.
+ */
+declare class XrmForgeError extends Error {
+    readonly code: ErrorCode;
+    readonly context: Record<string, unknown>;
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Authentication-specific error.
+ */
+declare class AuthenticationError extends XrmForgeError {
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Dataverse API request error.
+ */
+declare class ApiRequestError extends XrmForgeError {
+    readonly statusCode: number | undefined;
+    readonly responseBody: string | undefined;
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown> & {
+        statusCode?: number;
+        responseBody?: string;
+        url?: string;
+    });
+}
+/**
+ * Metadata retrieval or parsing error.
+ */
+declare class MetadataError extends XrmForgeError {
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Type generation or file output error.
+ */
+declare class GenerationError extends XrmForgeError {
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Configuration validation error.
+ */
+declare class ConfigError extends XrmForgeError {
+    constructor(code: ErrorCode, message: string, context?: Record<string, unknown>);
+}
+/**
+ * Type guard to check if an unknown error is an XrmForgeError.
+ */
+declare function isXrmForgeError(error: unknown): error is XrmForgeError;
+/**
+ * Type guard for API rate limit errors (HTTP 429).
+ */
+declare function isRateLimitError(error: unknown): error is ApiRequestError;
+
+/**
+ * @xrmforge/typegen - Logger
+ *
+ * Abstracted logging interface that decouples log output from the modules.
+ * Supports: CLI (human-readable), CI/CD (structured JSON), silent (library use).
+ *
+ * Every logger instance carries a `scope` (e.g. "auth", "metadata", "http")
+ * so log consumers can filter by origin module.
+ *
+ * Consumers can provide their own LogSink to integrate with any logging framework.
+ */
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+interface LogEntry {
+    level: LogLevel;
+    scope: string;
+    message: string;
+    context?: Record<string, unknown>;
+    timestamp: Date;
+}
+/**
+ * Interface for log output destinations.
+ * Implement this to route XrmForge logs into your own logging system.
+ */
+interface LogSink {
+    write(entry: LogEntry): void;
+    /**
+     * Write an inline progress update (no trailing newline).
+     * Used for long-running operations where each entity gets a status indicator.
+     *
+     * Sinks that don't support inline progress (e.g. JSON) should fall back
+     * to writing a regular INFO entry.
+     */
+    writeProgress(message: string): void;
+    /**
+     * Complete an inline progress line with a trailing message and newline.
+     */
+    writeProgressEnd(message: string): void;
+}
+/**
+ * Default CLI log sink with human-readable output and ANSI color indicators.
+ */
+declare class ConsoleLogSink implements LogSink {
+    private static readonly LEVEL_PREFIX;
+    write(entry: LogEntry): void;
+    writeProgress(message: string): void;
+    writeProgressEnd(message: string): void;
+}
+/**
+ * Structured JSON log sink for CI/CD pipelines and machine-readable output.
+ */
+declare class JsonLogSink implements LogSink {
+    write(entry: LogEntry): void;
+    writeProgress(message: string): void;
+    writeProgressEnd(message: string): void;
+}
+/**
+ * Silent log sink that discards all output. Used when running as a library.
+ */
+declare class SilentLogSink implements LogSink {
+    write(_entry: LogEntry): void;
+    writeProgress(_message: string): void;
+    writeProgressEnd(_message: string): void;
+}
+/**
+ * Logger with scope prefix and configurable sink/level.
+ *
+ * Usage:
+ * ```ts
+ * const log = createLogger('auth');
+ * log.info('Token acquired', { expiresIn: '3600s' });
+ * // Output: [INF] [auth] Token acquired
+ * ```
+ */
+declare class Logger {
+    private readonly scope;
+    private readonly getSink;
+    private readonly getMinLevel;
+    constructor(scope: string, getSink: () => LogSink, getMinLevel: () => LogLevel);
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Write an inline progress update (no newline).
+     */
+    progress(message: string): void;
+    /**
+     * Complete an inline progress line.
+     */
+    progressEnd(message: string): void;
+    private log;
+}
+/**
+ * Configure logging globally for all @xrmforge modules.
+ * Can be called at any time; existing loggers will pick up the new configuration
+ * automatically because they reference the shared state via closures.
+ *
+ * @example
+ * ```ts
+ * configureLogging({ sink: new JsonLogSink(), minLevel: LogLevel.WARN });
+ * ```
+ */
+declare function configureLogging(options: {
+    sink?: LogSink;
+    minLevel?: LogLevel;
+}): void;
+/**
+ * Create a scoped logger instance. All modules should use this instead of console.log.
+ *
+ * The logger reads the global sink and minLevel at each log call (not at creation time),
+ * so `configureLogging()` takes effect even on previously created loggers.
+ *
+ * @param scope - Module identifier shown in log output, e.g. "auth", "metadata", "http"
+ */
+declare function createLogger(scope: string): Logger;
+
+/**
+ * @xrmforge/typegen - Authentication Module
+ *
+ * Handles authentication to Dataverse Web API using MSAL (@azure/identity).
+ * Supports: Client Credentials (Service Principal), Interactive Browser, Device Code.
+ *
+ * Token acquisition and caching is handled by the DataverseHttpClient.
+ * This module is responsible only for creating the correct TokenCredential.
+ */
+
+type AuthMethod = 'client-credentials' | 'interactive' | 'device-code' | 'token';
+interface ClientCredentialsAuth {
+    method: 'client-credentials';
+    tenantId: string;
+    clientId: string;
+    clientSecret: string;
+}
+interface InteractiveAuth {
+    method: 'interactive';
+    tenantId?: string;
+    clientId?: string;
+}
+interface DeviceCodeAuth {
+    method: 'device-code';
+    tenantId?: string;
+    clientId?: string;
+}
+interface TokenAuth {
+    method: 'token';
+    /** Pre-acquired Bearer token (e.g. from TokenVault, Key Vault, CI/CD secret) */
+    token: string;
+}
+type AuthConfig = ClientCredentialsAuth | InteractiveAuth | DeviceCodeAuth | TokenAuth;
+/**
+ * Creates an Azure Identity TokenCredential from the provided auth configuration.
+ * Validates required fields before attempting credential creation.
+ *
+ * @throws {AuthenticationError} if required configuration values are missing
+ */
+declare function createCredential(config: AuthConfig): TokenCredential;
+
+/**
+ * @xrmforge/typegen - Dataverse HTTP Client
+ *
+ * Resilient HTTP client for the Dataverse Web API.
+ *
+ * Features:
+ * - Token caching with 5-minute buffer before expiry
+ * - Automatic retry with exponential backoff and jitter
+ * - Rate limit awareness (HTTP 429 with Retry-After)
+ * - Request timeout via AbortController
+ * - Concurrency control (semaphore pattern, NOT recursive)
+ * - Automatic OData paging via @odata.nextLink with safety limit
+ * - Input sanitization helpers against OData injection
+ */
+
+interface HttpClientOptions {
+    /** Dataverse environment URL, e.g. "https://myorg.crm4.dynamics.com" */
+    environmentUrl: string;
+    /** Azure Identity credential */
+    credential: TokenCredential;
+    /** API version (default: "v9.2") */
+    apiVersion?: string;
+    /** Maximum retry attempts for transient errors (default: 3) */
+    maxRetries?: number;
+    /** Base delay in ms for exponential backoff (default: 1000) */
+    retryBaseDelayMs?: number;
+    /** Request timeout in ms (default: 30000) */
+    timeoutMs?: number;
+    /** Maximum concurrent requests to Dataverse (default: 5) */
+    maxConcurrency?: number;
+    /** Maximum pages to follow via @odata.nextLink (default: 100, safety limit) */
+    maxPages?: number;
+    /** Maximum consecutive HTTP 429 retries before giving up (default: 10) */
+    maxRateLimitRetries?: number;
+    /**
+     * Read-only mode (default: true).
+     * When true, the client will ONLY allow GET requests and throw an error
+     * for any POST, PATCH, PUT, or DELETE attempt.
+     *
+     * SAFETY: XrmForge typegen is a read-only tool. It must NEVER modify
+     * data in Dataverse environments. This flag defaults to true and should
+     * only be set to false for the @xrmforge/webapi package (future).
+     */
+    readOnly?: boolean;
+}
+declare class DataverseHttpClient {
+    private readonly baseUrl;
+    private readonly apiVersion;
+    private readonly credential;
+    private readonly maxRetries;
+    private readonly retryBaseDelayMs;
+    private readonly timeoutMs;
+    private readonly maxConcurrency;
+    private readonly maxPages;
+    private readonly maxRateLimitRetries;
+    private readonly readOnly;
+    private cachedToken;
+    private activeConcurrentRequests;
+    private readonly waitQueue;
+    constructor(options: HttpClientOptions);
+    /**
+     * Full API base URL, e.g. "https://myorg.crm4.dynamics.com/api/data/v9.2"
+     */
+    get apiUrl(): string;
+    /**
+     * Execute a GET request against the Dataverse Web API.
+     * Handles token caching, retries, rate limits, and timeout.
+     *
+     * @param path - API path (relative or absolute URL)
+     * @param signal - Optional AbortSignal to cancel the request
+     */
+    get<T>(path: string, signal?: AbortSignal): Promise<T>;
+    /**
+     * Execute a GET request and automatically follow @odata.nextLink for paging.
+     * Returns all pages combined into a single array.
+     *
+     * Safety: Stops after `maxPages` iterations to prevent infinite loops.
+     *
+     * @param path - API path (relative or absolute URL)
+     * @param signal - Optional AbortSignal to cancel the request
+     */
+    getAll<T>(path: string, signal?: AbortSignal): Promise<T[]>;
+    /**
+     * Returns true if this client is in read-only mode (the safe default).
+     */
+    get isReadOnly(): boolean;
+    /**
+     * Assert that a non-GET operation is allowed.
+     * Throws immediately if the client is in read-only mode.
+     *
+     * @throws {ApiRequestError} always in read-only mode
+     * @internal This method exists so that future packages (e.g. @xrmforge/webapi)
+     * can reuse the HTTP client for write operations when readOnly is explicitly false.
+     */
+    assertWriteAllowed(operation: string): void;
+    /**
+     * Validate that a value is a safe OData identifier (entity name, attribute name).
+     * Prevents OData injection by allowing only: starts with letter/underscore,
+     * followed by alphanumeric/underscore.
+     *
+     * @throws {ApiRequestError} if the value contains invalid characters
+     */
+    static sanitizeIdentifier(value: string): string;
+    /**
+     * Validate that a value is a properly formatted GUID.
+     *
+     * @throws {ApiRequestError} if the format is invalid
+     */
+    static sanitizeGuid(value: string): string;
+    /**
+     * Escape a string for use inside OData single-quoted string literals.
+     * Doubles single quotes to prevent injection.
+     */
+    static escapeODataString(value: string): string;
+    private getToken;
+    /**
+     * Execute a request within the concurrency semaphore.
+     * The semaphore is acquired ONCE per logical request. Retries happen
+     * INSIDE the semaphore to avoid the recursive slot exhaustion bug.
+     */
+    private executeWithConcurrency;
+    private acquireSlot;
+    private releaseSlot;
+    private executeWithRetry;
+    private handleHttpError;
+    private resolveUrl;
+    private calculateBackoff;
+    private sleep;
+}
+
+/**
+ * @xrmforge/typegen - Metadata Types
+ *
+ * TypeScript interfaces for Dataverse Metadata API responses.
+ * These types model the JSON structures returned by the EntityDefinitions,
+ * Attributes, SystemForms, and GlobalOptionSetDefinitions endpoints.
+ */
+interface LocalizedLabel {
+    Label: string;
+    LanguageCode: number;
+}
+interface Label {
+    LocalizedLabels: LocalizedLabel[];
+    UserLocalizedLabel: LocalizedLabel | null;
+}
+interface EntityMetadata {
+    LogicalName: string;
+    SchemaName: string;
+    EntitySetName: string;
+    DisplayName: Label;
+    PrimaryIdAttribute: string;
+    PrimaryNameAttribute: string;
+    OwnershipType: string;
+    IsCustomEntity: boolean;
+    LogicalCollectionName: string;
+    MetadataId: string;
+    Attributes?: AttributeMetadata[];
+}
+interface AttributeMetadata {
+    '@odata.type'?: string;
+    LogicalName: string;
+    SchemaName: string;
+    AttributeType: string;
+    AttributeTypeName?: {
+        Value: string;
+    };
+    DisplayName: Label;
+    IsPrimaryId: boolean;
+    IsPrimaryName: boolean;
+    RequiredLevel: {
+        Value: string;
+    };
+    IsValidForRead: boolean;
+    IsValidForCreate: boolean;
+    IsValidForUpdate: boolean;
+    MetadataId: string;
+}
+interface StringAttributeMetadata extends AttributeMetadata {
+    MaxLength: number;
+    FormatName: {
+        Value: string;
+    } | null;
+}
+interface IntegerAttributeMetadata extends AttributeMetadata {
+    MaxValue: number;
+    MinValue: number;
+}
+interface DecimalAttributeMetadata extends AttributeMetadata {
+    MaxValue: number;
+    MinValue: number;
+    Precision: number;
+}
+interface MoneyAttributeMetadata extends AttributeMetadata {
+    MaxValue: number;
+    MinValue: number;
+    Precision: number;
+    PrecisionSource: number;
+}
+interface DateTimeAttributeMetadata extends AttributeMetadata {
+    DateTimeBehavior: {
+        Value: string;
+    };
+    Format: string;
+}
+interface LookupAttributeMetadata extends AttributeMetadata {
+    Targets: string[];
+}
+interface PicklistAttributeMetadata extends AttributeMetadata {
+    OptionSet: OptionSetMetadata | null;
+    GlobalOptionSet: OptionSetMetadata | null;
+}
+interface StatusAttributeMetadata extends AttributeMetadata {
+    OptionSet: OptionSetMetadata | null;
+}
+interface StateAttributeMetadata extends AttributeMetadata {
+    OptionSet: OptionSetMetadata | null;
+}
+interface OptionMetadata {
+    Value: number;
+    Label: Label;
+    Description: Label;
+    Color: string | null;
+}
+interface OptionSetMetadata {
+    '@odata.type'?: string;
+    Name: string;
+    DisplayName: Label;
+    IsCustomOptionSet: boolean;
+    IsGlobal: boolean;
+    OptionSetType: string;
+    Options: OptionMetadata[];
+    MetadataId: string;
+}
+interface SystemFormMetadata {
+    name: string;
+    formid: string;
+    formxml: string;
+    description: string | null;
+    isdefault: boolean;
+}
+/** Parsed data-bound control from FormXml (bound to an attribute) */
+interface FormControl {
+    /** Control ID (often same as datafieldname) */
+    id: string;
+    /** Attribute logical name this control is bound to */
+    datafieldname: string;
+    /** Control class ID (GUID identifying the control type) */
+    classid: string;
+}
+/** Type of special (non-data-bound) control on a form */
+type SpecialControlType = 'subgrid' | 'editablegrid' | 'quickview' | 'webresource' | 'iframe' | 'notes' | 'map' | 'timer' | 'unknown';
+/** Parsed special control from FormXml (subgrid, quick view, web resource, etc.) */
+interface FormSpecialControl {
+    /** Control ID (used for getControl) */
+    id: string;
+    /** Control class ID (GUID) */
+    classid: string;
+    /** Resolved control type */
+    controlType: SpecialControlType;
+    /** Target entity for subgrids (from parameters) */
+    targetEntityType?: string;
+    /** Relationship name for subgrids (from parameters) */
+    relationshipName?: string;
+    /** Web resource name (for web resource controls) */
+    webResourceName?: string;
+}
+/** Parsed tab from FormXml */
+interface FormTab {
+    name: string;
+    /** Tab label (for display, may be localized) */
+    label?: string;
+    /** Whether the tab is visible by default */
+    visible?: boolean;
+    sections: FormSection[];
+}
+/** Parsed section from FormXml */
+interface FormSection {
+    name: string;
+    /** Section label */
+    label?: string;
+    /** Whether the section is visible by default */
+    visible?: boolean;
+    controls: FormControl[];
+    /** Special controls in this section (subgrids, quick views, etc.) */
+    specialControls: FormSpecialControl[];
+}
+/** Parsed form structure */
+interface ParsedForm {
+    name: string;
+    formId: string;
+    isDefault: boolean;
+    tabs: FormTab[];
+    /** All data-bound controls across all tabs/sections (flattened) */
+    allControls: FormControl[];
+    /** All special controls across all tabs/sections (flattened) */
+    allSpecialControls: FormSpecialControl[];
+}
+interface OneToManyRelationshipMetadata {
+    SchemaName: string;
+    ReferencingEntity: string;
+    ReferencingAttribute: string;
+    ReferencedEntity: string;
+    ReferencedAttribute: string;
+    MetadataId: string;
+}
+interface ManyToManyRelationshipMetadata {
+    SchemaName: string;
+    Entity1LogicalName: string;
+    Entity2LogicalName: string;
+    IntersectEntityName: string;
+    MetadataId: string;
+}
+interface SolutionComponent {
+    objectid: string;
+    componenttype: number;
+}
+/** Complete metadata for a single entity, ready for type generation */
+interface EntityTypeInfo {
+    entity: EntityMetadata;
+    attributes: AttributeMetadata[];
+    picklistAttributes: PicklistAttributeMetadata[];
+    lookupAttributes: LookupAttributeMetadata[];
+    statusAttributes: StatusAttributeMetadata[];
+    stateAttributes: StateAttributeMetadata[];
+    forms: ParsedForm[];
+    oneToManyRelationships: OneToManyRelationshipMetadata[];
+    manyToManyRelationships: ManyToManyRelationshipMetadata[];
+}
+
+/**
+ * @xrmforge/typegen - Metadata Client
+ *
+ * High-level client for querying Dataverse Metadata API endpoints.
+ * Built on top of DataverseHttpClient for resilient HTTP communication.
+ *
+ * Provides methods for:
+ * - Entity metadata with attributes
+ * - Typed attribute queries (Picklist, Lookup, Status/State)
+ * - Form metadata (SystemForms + FormXml parsing)
+ * - Global OptionSet definitions
+ * - Solution-based entity filtering
+ * - Relationship metadata (1:N, N:N)
+ */
+
+declare class MetadataClient {
+    private readonly http;
+    constructor(httpClient: DataverseHttpClient);
+    /**
+     * Get metadata for a single entity by LogicalName, including all attributes.
+     *
+     * @throws {MetadataError} if the entity is not found
+     */
+    getEntityWithAttributes(logicalName: string): Promise<EntityMetadata>;
+    /**
+     * List all entities (without attributes) for discovery.
+     * Use `$filter` parameter to narrow results.
+     */
+    listEntities(filter?: string): Promise<EntityMetadata[]>;
+    /**
+     * Get all Picklist attributes with their OptionSets for an entity.
+     * Includes both local and global OptionSets.
+     */
+    getPicklistAttributes(logicalName: string): Promise<PicklistAttributeMetadata[]>;
+    /**
+     * Get all Lookup attributes with their target entity names.
+     */
+    getLookupAttributes(logicalName: string): Promise<LookupAttributeMetadata[]>;
+    /**
+     * Get Status attributes (statuscode) with their OptionSets.
+     */
+    getStatusAttributes(logicalName: string): Promise<StatusAttributeMetadata[]>;
+    /**
+     * Get State attributes (statecode) with their OptionSets.
+     */
+    getStateAttributes(logicalName: string): Promise<StateAttributeMetadata[]>;
+    /**
+     * Get and parse Main forms (type=2) for an entity.
+     * Returns parsed form structures with tabs, sections, and controls.
+     */
+    getMainForms(logicalName: string): Promise<ParsedForm[]>;
+    /**
+     * Get a global OptionSet by its exact name.
+     */
+    getGlobalOptionSet(name: string): Promise<OptionSetMetadata>;
+    /**
+     * List all global OptionSets (names and types only).
+     */
+    listGlobalOptionSets(): Promise<OptionSetMetadata[]>;
+    /**
+     * Get all 1:N relationships where this entity is the referenced (parent) entity.
+     */
+    getOneToManyRelationships(logicalName: string): Promise<OneToManyRelationshipMetadata[]>;
+    /**
+     * Get all N:N relationships for an entity.
+     */
+    getManyToManyRelationships(logicalName: string): Promise<ManyToManyRelationshipMetadata[]>;
+    /**
+     * Get all entity LogicalNames that belong to a specific solution.
+     * Resolves SolutionComponent MetadataIds to EntityDefinition LogicalNames.
+     *
+     * @param solutionUniqueName - The unique name of the solution
+     * @returns Array of entity LogicalNames (e.g. ["account", "contact"])
+     */
+    getEntityNamesForSolution(solutionUniqueName: string): Promise<string[]>;
+    /**
+     * Get all entity LogicalNames from multiple solutions, merged and deduplicated.
+     *
+     * @param solutionUniqueNames - Array of solution unique names
+     * @returns Deduplicated array of entity LogicalNames
+     */
+    getEntityNamesForSolutions(solutionUniqueNames: string[]): Promise<string[]>;
+    /**
+     * Fetch complete metadata for a single entity: all attributes (typed),
+     * forms, and relationships. This is the primary method for type generation.
+     *
+     * Makes 7 parallel API calls per entity for optimal performance.
+     */
+    getEntityTypeInfo(logicalName: string): Promise<EntityTypeInfo>;
+    /**
+     * Fetch complete metadata for multiple entities in parallel.
+     * Respects the HTTP client's concurrency limit automatically.
+     */
+    getMultipleEntityTypeInfos(logicalNames: string[]): Promise<EntityTypeInfo[]>;
+    private getRelationships;
+}
+
+/**
+ * @xrmforge/typegen - Metadata Cache
+ *
+ * File-system based metadata cache using Dataverse's RetrieveMetadataChanges
+ * ServerVersionStamp for efficient delta detection.
+ *
+ * On first run: full metadata retrieval, saved to .xrmforge/cache/metadata.json
+ * On subsequent runs: delta query with stored VersionStamp, only changed entities refreshed
+ * On expired stamp (90-day window or system maintenance): automatic full reload
+ *
+ * @see https://learn.microsoft.com/en-us/power-apps/developer/data-platform/cache-schema-data
+ */
+
+interface CacheManifest {
+    /** XrmForge version that created this cache */
+    version: string;
+    /** Dataverse environment URL */
+    environmentUrl: string;
+    /** ServerVersionStamp from last RetrieveMetadataChanges call */
+    serverVersionStamp: string | null;
+    /** ISO timestamp of last full or delta refresh */
+    lastRefreshed: string;
+    /** Entity logical names in this cache */
+    entities: string[];
+}
+interface CacheData {
+    manifest: CacheManifest;
+    entityTypeInfos: Record<string, EntityTypeInfo>;
+}
+declare class MetadataCache {
+    private readonly cacheDir;
+    private readonly cacheFilePath;
+    /**
+     * @param projectRoot - Root directory of the project (where .xrmforge/ will be created)
+     */
+    constructor(projectRoot: string);
+    /**
+     * Load cached metadata from disk.
+     * Returns null if no cache exists, cache is for a different environment,
+     * or cache format is incompatible.
+     */
+    load(environmentUrl: string): Promise<CacheData | null>;
+    /**
+     * Save metadata to the file-system cache.
+     */
+    save(environmentUrl: string, entityTypeInfos: Record<string, EntityTypeInfo>, serverVersionStamp: string | null): Promise<void>;
+    /**
+     * Get the stored ServerVersionStamp for delta queries.
+     * Returns null if no cache exists.
+     */
+    getVersionStamp(environmentUrl: string): Promise<string | null>;
+    /**
+     * Update specific entities in the cache (delta update).
+     * Merges new/changed entities into the existing cache.
+     */
+    updateEntities(environmentUrl: string, updatedEntities: Record<string, EntityTypeInfo>, newVersionStamp: string | null): Promise<void>;
+    /**
+     * Remove specific entities from the cache (for deleted entities).
+     */
+    removeEntities(environmentUrl: string, deletedEntityNames: string[], newVersionStamp: string | null): Promise<void>;
+    /**
+     * Delete the entire cache.
+     */
+    clear(): Promise<void>;
+    /**
+     * Check if a cache file exists.
+     */
+    exists(): Promise<boolean>;
+}
+
+/**
+ * @xrmforge/typegen - Label Utilities
+ *
+ * Extracts and formats localized labels from Dataverse metadata.
+ * Supports dual-language output (Goldene Regel 15):
+ * - Primary language for identifiers and first JSDoc line
+ * - Secondary language as optional addition in JSDoc
+ *
+ * Format: "Primary Label | Sekundäres Label"
+ * If secondary language is not available: "Primary Label" only.
+ */
+
+interface LabelConfig {
+    /** Primary language LCID (used for identifiers and first JSDoc line). Default: 1033 (English) */
+    primaryLanguage: number;
+    /** Optional secondary language LCID (added as comment). Example: 1031 (German) */
+    secondaryLanguage?: number;
+}
+/** Default: English only */
+declare const DEFAULT_LABEL_CONFIG: LabelConfig;
+/**
+ * Extract a label string for the primary language.
+ * Falls back to UserLocalizedLabel if the specific LCID is not found.
+ * Returns empty string if no label is available.
+ */
+declare function getPrimaryLabel(label: Label | null | undefined, config: LabelConfig): string;
+/**
+ * Extract a dual-language JSDoc string.
+ * Returns "Primary | Secondary" if both languages available,
+ * or just "Primary" if secondary is missing or not configured.
+ */
+declare function getJSDocLabel(label: Label | null | undefined, config: LabelConfig): string;
+/**
+ * Convert a label string to a valid TypeScript identifier (PascalCase).
+ * Transliterates German umlauts (ä to ae, ö to oe, ü to ue, ß to ss),
+ * then removes remaining invalid characters.
+ *
+ * @returns A valid TypeScript identifier, or null if the label cannot be converted
+ */
+declare function labelToIdentifier(label: string): string | null;
+/**
+ * Generate unique enum member names from OptionSet labels.
+ * Handles duplicates by appending _{Value} to colliding names.
+ * Falls back to Value_{numericValue} for unconvertible labels.
+ *
+ * @param options - Array of { Value, Label } from OptionSetMetadata
+ * @param config - Label configuration for language selection
+ * @returns Array of { name, value, jsDocLabel } for enum generation
+ */
+declare function generateEnumMembers(options: Array<{
+    Value: number;
+    Label: Label;
+}>, config: LabelConfig): Array<{
+    name: string;
+    value: number;
+    jsDocLabel: string;
+}>;
+/**
+ * Build the LabelLanguages query parameter for Dataverse Metadata API.
+ * Returns the parameter string to append to metadata queries.
+ *
+ * @example
+ * getLabelLanguagesParam({ primaryLanguage: 1033, secondaryLanguage: 1031 })
+ * // Returns "&LabelLanguages=1033,1031"
+ */
+declare function getLabelLanguagesParam(config: LabelConfig): string;
+
+/**
+ * @xrmforge/typegen - XML Parser Abstraction
+ *
+ * Interface for XML parsing, decoupled from any specific parser library.
+ * Allows swapping the underlying parser (currently fast-xml-parser)
+ * by implementing a single interface. (Goldene Regel 14)
+ */
+/**
+ * Parsed XML element with attributes and children.
+ */
+interface XmlElement {
+    /** Element tag name */
+    tag: string;
+    /** Element attributes as key-value pairs */
+    attributes: Record<string, string>;
+    /** Child elements */
+    children: XmlElement[];
+    /** Text content (if any) */
+    text?: string;
+}
+/**
+ * Abstraction for XML parsing. Implementations must convert an XML string
+ * into a tree of XmlElement objects.
+ *
+ * To swap the underlying parser library, implement this interface
+ * and pass it to the FormXml parser. Only this file needs to change.
+ */
+interface XmlParser {
+    parse(xml: string): XmlElement;
+}
+/**
+ * XML parser implementation using fast-xml-parser.
+ * Zero dependencies (fast-xml-parser itself has none), 26 KB minified.
+ */
+declare class FastXmlParser implements XmlParser {
+    private readonly parser;
+    constructor();
+    parse(xml: string): XmlElement;
+    private convertToXmlElement;
+    private convertNode;
+}
+/** Default parser instance. Use this unless you need a custom parser. */
+declare const defaultXmlParser: XmlParser;
+
+/**
+ * @xrmforge/typegen - FormXml Parser
+ *
+ * Parses Dataverse FormXml into structured TypeScript objects.
+ * Extracts tabs, sections, controls (data-bound + special) for generating
+ * typed FormContext interfaces with compile-time field validation.
+ *
+ * Uses the XmlParser abstraction (Goldene Regel 14) instead of regex.
+ */
+
+/**
+ * Parse a SystemFormMetadata response into a structured ParsedForm.
+ *
+ * @param form - The system form metadata from the API
+ * @param parser - XML parser to use (defaults to fast-xml-parser)
+ * @throws {MetadataError} if the formxml cannot be parsed
+ */
+declare function parseForm(form: SystemFormMetadata, parser?: XmlParser): ParsedForm;
+/**
+ * Extract all data-bound control field names from FormXml (flattened).
+ * Simpler alternative to full parsing when only the field list is needed.
+ */
+declare function extractControlFields(formxml: string, parser?: XmlParser): string[];
+
+/**
+ * @xrmforge/typegen - Type Mapping
+ *
+ * Maps Dataverse AttributeType values to TypeScript types for:
+ * 1. Entity interfaces (Web API data types)
+ * 2. Form interfaces (Xrm.Attributes.* types from @types/xrm)
+ * 3. Control interfaces (Xrm.Controls.* types from @types/xrm)
+ *
+ * This is the bridge between Dataverse metadata and generated TypeScript.
+ * Goldene Regel 1: All types extend @types/xrm, never replace.
+ */
+
+/**
+ * Map Dataverse AttributeType to TypeScript type for entity interfaces.
+ * These represent the raw data types returned by the Web API.
+ *
+ * @param attributeType - The AttributeType from Dataverse metadata
+ * @param isLookup - Whether this is a lookup field (uses _fieldname_value pattern)
+ * @returns TypeScript type string (e.g. "string", "number", "boolean")
+ */
+declare function getEntityPropertyType(attributeType: string, isLookup?: boolean): string;
+/**
+ * Map Dataverse AttributeType to Xrm.Attributes.* type for form interfaces.
+ * These represent the getAttribute() return types on FormContext.
+ *
+ * @param attributeType - The AttributeType from Dataverse metadata
+ * @returns Fully qualified Xrm attribute type string
+ */
+declare function getFormAttributeType(attributeType: string): string;
+/**
+ * Map Dataverse AttributeType to Xrm.Controls.* type for form interfaces.
+ * These represent the getControl() return types on FormContext.
+ *
+ * @param attributeType - The AttributeType from Dataverse metadata
+ * @returns Fully qualified Xrm control type string
+ */
+declare function getFormControlType(attributeType: string): string;
+/**
+ * Convert a Dataverse LogicalName to a safe TypeScript identifier.
+ * Validates that the result is a valid identifier.
+ *
+ * @param logicalName - Dataverse field or entity logical name
+ * @returns A valid TypeScript identifier
+ * @throws Never throws; returns the input if already valid, prefixes with _ if starts with digit
+ */
+declare function toSafeIdentifier(logicalName: string): string;
+/**
+ * Convert a Dataverse LogicalName to PascalCase for use as interface/type name.
+ *
+ * @example
+ * toPascalCase('account') // 'Account'
+ * toPascalCase('markant_cdhcontactsource') // 'MarkantCdhcontactsource'
+ */
+declare function toPascalCase(logicalName: string): string;
+/**
+ * Convert a lookup attribute LogicalName to its Web API value property name.
+ * In the Web API, lookup fields are represented as `_fieldname_value`.
+ *
+ * @example
+ * toLookupValueProperty('primarycontactid') // '_primarycontactid_value'
+ * toLookupValueProperty('ownerid') // '_ownerid_value'
+ */
+declare function toLookupValueProperty(logicalName: string): string;
+/**
+ * Determine if an attribute is a single-value lookup type.
+ * PartyList is NOT included: it's a collection navigation property (ActivityParty[]),
+ * not a single _fieldname_value property in the Web API.
+ */
+declare function isLookupType(attributeType: string): boolean;
+/**
+ * Determine if an attribute should be included in entity interfaces.
+ * Excludes virtual/calculated fields that are not readable via Web API.
+ *
+ * Filtered types:
+ * - Virtual, CalendarRules: not readable via Web API
+ * - ManagedProperty: solution metadata (iscustomizable etc.), not business data
+ * - EntityName: internal companion fields for lookups; entity type info is only
+ *   available via @Microsoft.Dynamics.CRM.lookuplogicalname OData annotation,
+ *   not as a standalone property in Web API responses
+ */
+declare function shouldIncludeInEntityInterface(attr: AttributeMetadata): boolean;
+
+/**
+ * @xrmforge/typegen - Generator-specific Label Utilities
+ *
+ * This module contains ONLY generator-specific label functions.
+ * Core label extraction (getPrimaryLabel, getJSDocLabel, LabelConfig etc.)
+ * is provided by the canonical implementation in metadata/labels.ts (R6-02).
+ *
+ * Re-exports from metadata/labels.ts are provided for convenience.
+ */
+
+/**
+ * Extract the secondary language label, if configured and available.
+ * Returns undefined if no secondary language is configured or label not found.
+ */
+declare function getSecondaryLabel(label: Label, config: LabelConfig): string | undefined;
+/**
+ * Disambiguate duplicate enum member names by appending the numeric value.
+ * Only the second and subsequent duplicates get the suffix.
+ * Re-checks that the suffixed name doesn't collide with an existing name.
+ *
+ * @example
+ * disambiguateEnumMembers([
+ *   { name: "Active", value: 1 },
+ *   { name: "Active", value: 2 },
+ * ])
+ * // [{ name: "Active", value: 1 }, { name: "Active_2", value: 2 }]
+ *
+ * // Edge case: "Active_2" already exists as a label-derived name
+ * disambiguateEnumMembers([
+ *   { name: "Active", value: 1 },
+ *   { name: "Active", value: 2 },
+ *   { name: "Active_2", value: 3 },
+ * ])
+ * // [{ name: "Active", value: 1 }, { name: "Active_2_v2", value: 2 }, { name: "Active_2", value: 3 }]
+ */
+declare function disambiguateEnumMembers(members: Array<{
+    name: string;
+    value: number;
+}>): Array<{
+    name: string;
+    value: number;
+}>;
+
+/**
+ * @xrmforge/typegen - Entity Interface Generator
+ *
+ * Generates TypeScript declaration files (.d.ts) for Dataverse entity interfaces.
+ * These interfaces represent the data types returned by the Web API.
+ *
+ * Output pattern:
+ * ```typescript
+ * declare namespace XrmForge.Entities {
+ *   interface Account {
+ *     accountid: string | null;
+ *     name: string | null;
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+
+/** Options for entity interface generation */
+interface EntityGeneratorOptions {
+    /** Label configuration for dual-language JSDoc comments */
+    labelConfig?: LabelConfig;
+    /** Namespace for generated types (default: "XrmForge.Entities") */
+    namespace?: string;
+}
+/**
+ * Generate a TypeScript declaration for an entity interface.
+ *
+ * @param info - Complete entity metadata (from MetadataClient.getEntityTypeInfo)
+ * @param options - Generator options
+ * @returns TypeScript declaration string (.d.ts content)
+ */
+declare function generateEntityInterface(info: EntityTypeInfo, options?: EntityGeneratorOptions): string;
+
+/**
+ * @xrmforge/typegen - OptionSet Enum Generator
+ *
+ * Generates TypeScript const enums from Dataverse OptionSet metadata.
+ * Uses const enum because D365 form scripts have no module system at runtime,
+ * so enum values must be inlined at compile time.
+ *
+ * Output pattern:
+ * ```typescript
+ * declare namespace XrmForge.OptionSets {
+ *   const enum AccountCategoryCode {
+ *     PreferredCustomer = 1,
+ *     Standard = 2,
+ *   }
+ * }
+ * ```
+ */
+
+/** Options for OptionSet enum generation */
+interface OptionSetGeneratorOptions {
+    /** Label configuration for dual-language JSDoc comments */
+    labelConfig?: LabelConfig;
+    /** Namespace for generated types (default: "XrmForge.OptionSets") */
+    namespace?: string;
+}
+/**
+ * Generate a TypeScript const enum declaration from an OptionSet.
+ *
+ * @param optionSet - OptionSet metadata from Dataverse
+ * @param entityLogicalName - Entity this OptionSet belongs to (for naming local OptionSets)
+ * @param attributeSchemaName - Attribute schema name (for naming local OptionSets)
+ * @param options - Generator options
+ * @returns TypeScript const enum declaration string
+ */
+declare function generateOptionSetEnum(optionSet: OptionSetMetadata, _entityLogicalName: string, attributeSchemaName: string, options?: OptionSetGeneratorOptions): string;
+/**
+ * Generate multiple OptionSet enums for all picklist attributes of an entity.
+ * Handles both local and global OptionSets.
+ *
+ * @param picklistAttributes - Picklist attributes with their OptionSet metadata
+ * @param entityLogicalName - Entity logical name
+ * @param options - Generator options
+ * @returns Array of { enumName, content } for each generated enum
+ */
+declare function generateEntityOptionSets(picklistAttributes: Array<{
+    SchemaName: string;
+    OptionSet: OptionSetMetadata | null;
+    GlobalOptionSet: OptionSetMetadata | null;
+}>, entityLogicalName: string, options?: OptionSetGeneratorOptions): Array<{
+    enumName: string;
+    content: string;
+}>;
+
+/**
+ * @xrmforge/typegen - Form Interface Generator
+ *
+ * Generates TypeScript form interfaces with compile-time field validation.
+ *
+ * Architecture:
+ * 1. Union Type (LeadFormFields): restricts getAttribute to form-specific fields only
+ * 2. Mapped Return Type (LeadAttributeMap): maps field name to correct Xrm type
+ * 3. Generic getAttribute<K>: returns the exact type for each field
+ * 4. Fields const enum: provides autocomplete with dual-language labels
+ * 5. NO fallback getAttribute(name: string): unknown fields are compile errors
+ *
+ * Output pattern:
+ * ```typescript
+ * declare namespace XrmForge.Forms.Account {
+ *   type AccountMainFormFields = "name" | "telephone1" | "revenue";
+ *
+ *   type AccountMainFormAttributeMap = {
+ *     name: Xrm.Attributes.StringAttribute;
+ *     telephone1: Xrm.Attributes.StringAttribute;
+ *     revenue: Xrm.Attributes.NumberAttribute;
+ *   };
+ *
+ *   type AccountMainFormControlMap = {
+ *     name: Xrm.Controls.StringControl;
+ *     telephone1: Xrm.Controls.StringControl;
+ *     revenue: Xrm.Controls.NumberControl;
+ *   };
+ *
+ *   const enum AccountMainFormFields {
+ *     Name = 'name',
+ *     Telephone1 = 'telephone1',
+ *     Revenue = 'revenue',
+ *   }
+ *
+ *   interface AccountMainForm extends Omit<Xrm.FormContext, 'getAttribute' | 'getControl'> {
+ *     getAttribute<K extends AccountMainFormFields>(name: K): AccountMainFormAttributeMap[K];
+ *     getAttribute(index: number): Xrm.Attributes.Attribute;
+ *     getAttribute(): Xrm.Attributes.Attribute[];
+ *     getControl<K extends AccountMainFormFields>(name: K): AccountMainFormControlMap[K];
+ *     getControl(index: number): Xrm.Controls.Control;
+ *     getControl(): Xrm.Controls.Control[];
+ *   }
+ * }
+ * ```
+ */
+
+/** Options for form interface generation */
+interface FormGeneratorOptions {
+    /** Label configuration for dual-language JSDoc comments */
+    labelConfig?: LabelConfig;
+    /** Namespace prefix for generated types (default: "XrmForge.Forms") */
+    namespacePrefix?: string;
+    /** Form types to include (default: [2] = Main only) */
+    formTypes?: number[];
+}
+/**
+ * Generate a complete form declaration: union type, mapped types, fields enum, and interface.
+ *
+ * @param form - Parsed form structure (from FormXml parser)
+ * @param entityLogicalName - Entity this form belongs to
+ * @param attributeMap - Map of LogicalName to AttributeMetadata for type resolution
+ * @param options - Generator options
+ * @returns TypeScript declaration string
+ */
+declare function generateFormInterface(form: ParsedForm, entityLogicalName: string, attributeMap: Map<string, AttributeMetadata>, options?: FormGeneratorOptions, baseNameOverride?: string): string;
+/**
+ * Generate form interfaces for all forms of an entity.
+ *
+ * @param forms - Parsed forms (from FormXml parser)
+ * @param entityLogicalName - Entity logical name
+ * @param attributes - All attributes of the entity (for type resolution)
+ * @param options - Generator options
+ * @returns Array of { formName, interfaceName, content }
+ */
+declare function generateEntityForms(forms: ParsedForm[], entityLogicalName: string, attributes: AttributeMetadata[], options?: FormGeneratorOptions): Array<{
+    formName: string;
+    interfaceName: string;
+    content: string;
+}>;
+
+/**
+ * @xrmforge/typegen - Orchestrator Types
+ *
+ * Configuration and result types for the type generation orchestrator.
+ */
+
+/** Configuration for the type generation process */
+interface GenerateConfig {
+    /** Dataverse environment URL (e.g. "https://myorg.crm4.dynamics.com") */
+    environmentUrl: string;
+    /** Entity logical names to generate types for (merged with solution entities if both set) */
+    entities: string[];
+    /** Solution unique names to discover entities automatically (merged with entities, deduplicated) */
+    solutionNames?: string[];
+    /** Output directory for generated .d.ts files */
+    outputDir: string;
+    /** Label language configuration */
+    labelConfig: LabelConfig;
+    /** Whether to generate entity interfaces (default: true) */
+    generateEntities?: boolean;
+    /** Whether to generate form interfaces (default: true) */
+    generateForms?: boolean;
+    /** Whether to generate OptionSet enums (default: true) */
+    generateOptionSets?: boolean;
+    /**
+     * Whether to use metadata cache for faster re-generation.
+     * @alpha Not yet implemented. Setting this to true will throw a ConfigError.
+     * Planned for v0.2.0.
+     * @defaultValue false
+     */
+    useCache?: boolean;
+    /**
+     * Cache directory for metadata cache.
+     * @alpha Not yet implemented. Ignored until useCache is implemented.
+     * Planned for v0.2.0.
+     * @defaultValue ".xrmforge/cache"
+     */
+    cacheDir?: string;
+    /** XrmForge namespace prefix (default: "XrmForge") */
+    namespacePrefix?: string;
+}
+/** Result of generating types for a single entity */
+interface EntityGenerationResult {
+    /** Entity logical name */
+    entityLogicalName: string;
+    /** Files written */
+    files: GeneratedFile[];
+    /** Warnings (e.g. missing labels, empty forms) */
+    warnings: string[];
+}
+/** A single generated file */
+interface GeneratedFile {
+    /** Relative path from outputDir */
+    relativePath: string;
+    /** File content */
+    content: string;
+    /** Type of generated content */
+    type: 'entity' | 'optionset' | 'form';
+}
+/** Overall result of the generation process */
+interface GenerationResult {
+    /** Per-entity results */
+    entities: EntityGenerationResult[];
+    /** Total files written */
+    totalFiles: number;
+    /** Total warnings */
+    totalWarnings: number;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+
+/**
+ * @xrmforge/typegen - Type Generation Orchestrator
+ *
+ * Coordinates the full type generation pipeline:
+ * 1. Fetch metadata for requested entities (via MetadataClient)
+ * 2. Generate entity interfaces, OptionSet enums, form interfaces
+ * 3. Write .d.ts files to disk
+ *
+ * This is the main entry point that ties all components together.
+ */
+
+/**
+ * Main orchestrator for type generation.
+ *
+ * Usage:
+ * ```typescript
+ * const orchestrator = new TypeGenerationOrchestrator(credential, {
+ *   environmentUrl: 'https://myorg.crm4.dynamics.com',
+ *   entities: ['account', 'contact'],
+ *   outputDir: './typings',
+ *   labelConfig: { primaryLanguage: 1033, secondaryLanguage: 1031 },
+ * });
+ * const result = await orchestrator.generate();
+ * ```
+ */
+declare class TypeGenerationOrchestrator {
+    private readonly config;
+    private readonly credential;
+    private readonly logger;
+    constructor(credential: TokenCredential, config: GenerateConfig, logger?: Logger);
+    /**
+     * Run the full type generation pipeline.
+     *
+     * @param options - Optional parameters
+     * @param options.signal - AbortSignal to cancel the generation process.
+     *   When aborted, entities that have not yet started processing are skipped.
+     *   Entities already in progress may still complete or fail with an abort error.
+     */
+    generate(options?: {
+        signal?: AbortSignal;
+    }): Promise<GenerationResult>;
+    /**
+     * Process a single entity: fetch metadata, generate all output files.
+     */
+    private processEntity;
+    /**
+     * Extract picklist attributes with their OptionSet metadata.
+     * Maps the raw EntityTypeInfo data to the format expected by the OptionSet generator.
+     */
+    private getPicklistAttributes;
+}
+
+export { ApiRequestError, type AttributeMetadata, type AuthConfig, type AuthMethod, AuthenticationError, type ClientCredentialsAuth, ConfigError, ConsoleLogSink, DEFAULT_LABEL_CONFIG, DataverseHttpClient, type DateTimeAttributeMetadata, type DecimalAttributeMetadata, type DeviceCodeAuth, type EntityGenerationResult, type EntityGeneratorOptions, type EntityMetadata, type EntityTypeInfo, ErrorCode, FastXmlParser, type FormControl, type FormGeneratorOptions, type FormSection, type FormTab, type GenerateConfig, type GeneratedFile, GenerationError, type GenerationResult, type HttpClientOptions, type IntegerAttributeMetadata, type InteractiveAuth, JsonLogSink, type Label, type LabelConfig, type LocalizedLabel, type LogEntry, LogLevel, type LogSink, Logger, type LookupAttributeMetadata, type ManyToManyRelationshipMetadata, MetadataCache, MetadataClient, MetadataError, type MoneyAttributeMetadata, type OneToManyRelationshipMetadata, type OptionMetadata, type OptionSetGeneratorOptions, type OptionSetMetadata, type ParsedForm, type PicklistAttributeMetadata, SilentLogSink, type SolutionComponent, type StateAttributeMetadata, type StatusAttributeMetadata, type StringAttributeMetadata, type SystemFormMetadata, TypeGenerationOrchestrator, type XmlElement, type XmlParser, XrmForgeError, configureLogging, createCredential, createLogger, defaultXmlParser, disambiguateEnumMembers, extractControlFields, getJSDocLabel as formatDualLabel, generateEntityForms, generateEntityInterface, generateEntityOptionSets, generateEnumMembers, generateFormInterface, generateOptionSetEnum, getEntityPropertyType, getFormAttributeType, getFormControlType, getJSDocLabel, getLabelLanguagesParam, getPrimaryLabel, getSecondaryLabel, isLookupType, isRateLimitError, isXrmForgeError, labelToIdentifier, parseForm, shouldIncludeInEntityInterface, toLookupValueProperty, toPascalCase, toSafeIdentifier };