type ClientOptions = {
    baseUrl: string;
};
type ServiceInfoResponseDto = {
    /**
     * Service name
     */
    service: string;
    /**
     * Documentation URL
     */
    documentation: string;
};
type VersionResponseDto = {
    /**
     * Running service version
     */
    version: string;
};
type GrafanaConfigDto = {
    /**
     * Base URL of the Grafana instance
     */
    url?: string;
    /**
     * UID of the Tempo data source in Grafana
     */
    tempoUid: string;
    /**
     * UID of the Loki data source in Grafana
     */
    lokiUid: string;
};
type FrontendConfigResponseDto = {
    /**
     * Grafana observability configuration
     */
    grafana: GrafanaConfigDto;
    /**
     * Active startup configuration import mode
     */
    configImportMode: 'disabled' | 'create' | 'upsert' | 'replace';
};
type RoleDto = {
    /**
     * OAuth2 roles
     */
    role: 'presentation:manage' | 'presentation:request' | 'issuance:manage' | 'issuance:offer' | 'clients:manage' | 'users:manage' | 'tenants:manage' | 'tenant:admin' | 'registrar:manage';
};
type ClientCredentialsDto = {
    grant_type?: string;
    client_id?: string;
    client_secret?: string;
};
type TokenResponse = {
    /**
     * Bearer access token
     */
    access_token: string;
    /**
     * Optional refresh token
     */
    refresh_token?: string;
    /**
     * Token type
     */
    token_type: string;
    /**
     * Access token lifetime in seconds
     */
    expires_in: number;
    /**
     * Opaque state value echoed from the request
     */
    state: string;
};
type OAuthTokenErrorResponseDto = {
    /**
     * OAuth2 error code
     */
    error: string;
    /**
     * Human-readable error description
     */
    error_description?: string;
    /**
     * URI identifying the error
     */
    error_uri?: string;
};
type KeyResponseDto = {
    /**
     * JSON Web Keys
     */
    keys: Array<{
        [key: string]: unknown;
    }>;
};
/**
 * Payload used when importing tenant metadata from config files.
 */
type ImportTenantDto = {
    /**
     * Display name of the tenant.
     */
    name?: string;
    /**
     * Optional tenant description.
     */
    description?: string;
    /**
     * Optional tenant-specific session storage configuration.
     */
    sessionConfig?: {
        /**
         * Session time-to-live in seconds.
         */
        ttlSeconds?: number;
        /**
         * Whether to fully delete or anonymize expired sessions.
         */
        cleanupMode?: 'full' | 'anonymize';
    };
    /**
     * Optional tenant-specific status list defaults.
     */
    statusListConfig?: {
        /**
         * Default status list capacity.
         */
        capacity?: number;
        /**
         * Bits-per-status setting (1, 2, 4, or 8).
         */
        bits?: 1 | 2 | 4 | 8;
        /**
         * JWT TTL for status list tokens in seconds.
         */
        ttl?: number;
        /**
         * Regenerate status list JWTs immediately after status updates.
         */
        immediateUpdate?: boolean;
        /**
         * Include aggregation_uri in generated status list JWTs.
         */
        enableAggregation?: boolean;
    };
};
type SessionStorageConfig = {
    /**
     * Time-to-live for sessions in seconds. If not set, uses global SESSION_TTL.
     */
    ttlSeconds?: number;
    /**
     * Cleanup mode: 'full' deletes everything, 'anonymize' keeps metadata but removes PII.
     */
    cleanupMode?: 'full' | 'anonymize';
};
type StatusListConfig = {
    /**
     * The capacity of the status list. If not set, uses global STATUS_CAPACITY.
     */
    capacity?: number;
    /**
     * Bits per status entry: 1 (valid/revoked), 2 (with suspended), 4/8 (extended). If not set, uses global STATUS_BITS.
     */
    bits?: 1 | 2 | 4 | 8;
    /**
     * TTL in seconds for the status list JWT. If not set, uses global STATUS_TTL.
     */
    ttl?: number;
    /**
     * If true, regenerate JWT immediately on status changes. If false (default), use lazy regeneration on TTL expiry.
     */
    immediateUpdate?: boolean;
    /**
     * If true, include aggregation_uri in status list JWTs for pre-fetching support (default: true).
     */
    enableAggregation?: boolean;
};
type ClientEntity = {
    /**
     * Unique client identifier
     */
    clientId: string;
    /**
     * Tenant identifier the client belongs to
     */
    tenantId?: string;
    /**
     * Client description
     */
    description?: string;
    /**
     * Roles assigned to the client
     */
    roles: Array<'presentation:manage' | 'presentation:request' | 'issuance:manage' | 'issuance:offer' | 'clients:manage' | 'users:manage' | 'tenants:manage' | 'tenant:admin' | 'registrar:manage'>;
    /**
     * List of presentation config IDs this client can use. If empty/null, all configs are allowed.
     */
    allowedPresentationConfigs?: Array<string> | null;
    /**
     * List of issuance config IDs this client can use. If empty/null, all configs are allowed.
     */
    allowedIssuanceConfigs?: Array<string> | null;
};
type TenantResponseDto = {
    /**
     * Unique tenant identifier
     */
    id: string;
    /**
     * Tenant display name
     */
    name: string;
    /**
     * Tenant description
     */
    description?: string | null;
    /**
     * Tenant status
     */
    status: string;
    /**
     * Session storage configuration for this tenant. Controls TTL and cleanup behavior.
     */
    sessionConfig?: SessionStorageConfig | null;
    /**
     * Status list configuration for this tenant. Only affects newly created status lists.
     */
    statusListConfig?: StatusListConfig | null;
    /**
     * Managed clients attached to the tenant
     */
    clients?: Array<ClientEntity>;
};
/**
 * Payload for creating a tenant.
 */
type CreateTenantDto = {
    /**
     * Unique tenant identifier.
     */
    id: string;
    /**
     * Display name of the tenant.
     */
    name?: string;
    /**
     * Optional tenant description.
     */
    description?: string;
    /**
     * Optional default role assignments for the tenant.
     */
    roles?: Array<'tenants:manage' | 'issuance:offer' | 'issuance:manage' | 'presentation:request' | 'presentation:manage' | 'clients:manage' | 'users:manage' | 'registrar:manage' | 'tenant:admin'>;
    /**
     * Optional tenant-specific session storage configuration.
     */
    sessionConfig?: {
        /**
         * Session time-to-live in seconds.
         */
        ttlSeconds?: number;
        /**
         * Whether to fully delete or anonymize expired sessions.
         */
        cleanupMode?: 'full' | 'anonymize';
    };
    /**
     * Optional tenant-specific status list defaults.
     */
    statusListConfig?: {
        /**
         * Default status list capacity.
         */
        capacity?: number;
        /**
         * Bits-per-status setting (1, 2, 4, or 8).
         */
        bits?: 1 | 2 | 4 | 8;
        /**
         * JWT TTL for status list tokens in seconds.
         */
        ttl?: number;
        /**
         * Regenerate status list JWTs immediately after status updates.
         */
        immediateUpdate?: boolean;
        /**
         * Include aggregation_uri in generated status list JWTs.
         */
        enableAggregation?: boolean;
    };
};
type TenantClientCredentialsDto = {
    /**
     * Generated client identifier
     */
    clientId: string;
    /**
     * Generated client secret
     */
    clientSecret: string;
};
type TenantCreateResponseDto = {
    /**
     * Unique tenant identifier
     */
    id: string;
    /**
     * Tenant display name
     */
    name: string;
    /**
     * Tenant description
     */
    description?: string | null;
    /**
     * Tenant status
     */
    status: string;
    /**
     * Session storage configuration for this tenant. Controls TTL and cleanup behavior.
     */
    sessionConfig?: SessionStorageConfig | null;
    /**
     * Status list configuration for this tenant. Only affects newly created status lists.
     */
    statusListConfig?: StatusListConfig | null;
    /**
     * One-time generated client credentials for admin access
     */
    client?: TenantClientCredentialsDto;
};
/**
 * Payload for partially updating tenant metadata.
 */
type UpdateTenantDto = {
    /**
     * Display name of the tenant.
     */
    name?: string;
    /**
     * Tenant description. Omit to keep the current value or set to null to remove it.
     */
    description?: string | null;
    /**
     * Optional tenant-specific session storage configuration.
     */
    sessionConfig?: {
        /**
         * Session time-to-live in seconds.
         */
        ttlSeconds?: number;
        /**
         * Whether to fully delete or anonymize expired sessions.
         */
        cleanupMode?: 'full' | 'anonymize';
    };
    /**
     * Optional tenant-specific status list defaults.
     */
    statusListConfig?: {
        /**
         * Default status list capacity.
         */
        capacity?: number;
        /**
         * Bits-per-status setting (1, 2, 4, or 8).
         */
        bits?: 1 | 2 | 4 | 8;
        /**
         * JWT TTL for status list tokens in seconds.
         */
        ttl?: number;
        /**
         * Regenerate status list JWTs immediately after status updates.
         */
        immediateUpdate?: boolean;
        /**
         * Include aggregation_uri in generated status list JWTs.
         */
        enableAggregation?: boolean;
    };
};
type AuditLogResponseDto = {
    id: string;
    tenantId: string;
    actionType: 'tenant_created' | 'tenant_updated' | 'tenant_deleted' | 'presentation_config_created' | 'presentation_config_updated' | 'presentation_config_deleted' | 'issuance_config_updated' | 'credential_config_created' | 'credential_config_updated' | 'credential_config_deleted' | 'status_list_config_updated' | 'status_list_config_reset' | 'webhook_endpoint_created' | 'webhook_endpoint_updated' | 'webhook_endpoint_deleted' | 'attribute_provider_created' | 'attribute_provider_updated' | 'attribute_provider_deleted' | 'config_bundle_exported' | 'config_bundle_imported' | 'config_client_secret_generated' | 'config_resource_detached';
    actorType: 'user' | 'client' | 'system';
    actorId?: string;
    actorDisplay?: string;
    changedFields?: Array<string>;
    before?: {
        [key: string]: unknown;
    };
    after?: {
        [key: string]: unknown;
    };
    requestId?: string;
    timestamp: string;
};
type ClientSecretResponseDto = {
    /**
     * One-time client secret
     */
    secret: string;
};
type UpdateClientDto = {
    /**
     * Optional updated description.
     */
    description?: string;
    /**
     * Optional replacement roles for the client.
     */
    roles?: Array<'presentation:manage' | 'presentation:request' | 'issuance:manage' | 'issuance:offer' | 'clients:manage' | 'users:manage' | 'tenants:manage' | 'tenant:admin' | 'registrar:manage'>;
    /**
     * Optional replacement allow-list of presentation config ids.
     */
    allowedPresentationConfigs?: Array<string> | null;
    /**
     * Optional replacement allow-list of issuance config ids.
     */
    allowedIssuanceConfigs?: Array<string> | null;
};
type CreateClientDto = {
    /**
     * Unique client identifier.
     */
    clientId: string;
    /**
     * Optional client secret for confidential clients.
     */
    secret?: string;
    /**
     * Optional human-readable client description.
     */
    description?: string;
    /**
     * Roles assigned to the client. At least one role is required.
     */
    roles: Array<'presentation:manage' | 'presentation:request' | 'issuance:manage' | 'issuance:offer' | 'clients:manage' | 'users:manage' | 'tenants:manage' | 'tenant:admin' | 'registrar:manage'>;
    /**
     * Optional allow-list of presentation config ids this client can use.
     */
    allowedPresentationConfigs?: Array<string> | null;
    /**
     * Optional allow-list of issuance config ids this client can use.
     */
    allowedIssuanceConfigs?: Array<string> | null;
};
type RegistrationCertificateDefaults = {
    /**
     * Default privacy policy URL for registration certificate creation.
     */
    privacy_policy?: string;
    /**
     * Default support contact URI for registration certificate creation.
     */
    support_uri?: string;
};
type RegistrarConfigResponseDto = {
    /**
     * The base URL of the registrar API
     */
    registrarUrl: string;
    /**
     * The OIDC issuer URL for authentication (e.g., Keycloak realm URL)
     */
    oidcUrl: string;
    /**
     * The OIDC client ID for the registrar
     */
    clientId: string;
    /**
     * The OIDC client secret (optional, for confidential clients)
     */
    clientSecret?: string;
    /**
     * The username for OIDC login
     */
    username: string;
    /**
     * Optional default values merged into registration certificate creation requests (for example privacy_policy, support_uri)
     */
    registrationCertificateDefaults?: RegistrationCertificateDefaults | null;
    /**
     * Indicates whether a password is configured (actual password is never returned)
     */
    hasPassword: boolean;
};
type CreateRegistrarConfigDto = {
    /**
     * Base URL of the registrar service.
     */
    registrarUrl: string;
    /**
     * OIDC discovery or issuer URL used for authentication.
     */
    oidcUrl: string;
    /**
     * OAuth client ID used against the registrar.
     */
    clientId: string;
    /**
     * Optional OAuth client secret for registrar authentication.
     */
    clientSecret?: string;
    /**
     * Username used for registrar authentication.
     */
    username: string;
    /**
     * Password used for registrar authentication.
     */
    password: string;
    /**
     * Optional default registration certificate values.
     */
    registrationCertificateDefaults?: {
        [key: string]: unknown;
    } | null;
};
type UpdateRegistrarConfigDto = {
    /**
     * Base URL of the registrar service.
     */
    registrarUrl?: string;
    /**
     * OIDC discovery or issuer URL used for authentication.
     */
    oidcUrl?: string;
    /**
     * OAuth client ID used against the registrar.
     */
    clientId?: string;
    /**
     * Optional OAuth client secret for registrar authentication.
     */
    clientSecret?: string;
    /**
     * Username used for registrar authentication.
     */
    username?: string;
    /**
     * Password used for registrar authentication.
     */
    password?: string;
    /**
     * Optional default registration certificate values.
     */
    registrationCertificateDefaults?: {
        [key: string]: unknown;
    } | null;
};
type CreateAccessCertificateDto = {
    /**
     * Key chain id used to issue the access certificate.
     */
    keyId: string;
};
type ManagedUserDto = {
    id: string;
    username: string;
    email?: string;
    enabled: boolean;
    roles: Array<'presentation:manage' | 'presentation:request' | 'issuance:manage' | 'issuance:offer' | 'clients:manage' | 'users:manage' | 'tenants:manage' | 'tenant:admin' | 'registrar:manage'>;
    tenantId?: string;
    /**
     * One-time temporary password returned only on user creation.
     */
    temporaryPassword?: string;
};
type CreateUserDto = {
    username: string;
    email?: string;
    roles: Array<'tenants:manage' | 'issuance:offer' | 'issuance:manage' | 'presentation:request' | 'presentation:manage' | 'clients:manage' | 'users:manage' | 'registrar:manage' | 'tenant:admin'>;
    enabled?: boolean;
};
type UpdateUserDto = {
    username?: string;
    email?: string;
    roles?: Array<'tenants:manage' | 'issuance:offer' | 'issuance:manage' | 'presentation:request' | 'presentation:manage' | 'clients:manage' | 'users:manage' | 'registrar:manage' | 'tenant:admin'>;
    enabled?: boolean;
    password?: string;
};
type KmsProviderCapabilitiesDto = {
    /**
     * Whether the provider supports importing existing keys.
     */
    canImport: boolean;
    /**
     * Whether the provider supports generating new keys.
     */
    canCreate: boolean;
    /**
     * Whether the provider supports deleting keys.
     */
    canDelete: boolean;
    /**
     * Signing algorithms supported by the provider.
     */
    supportedAlgs: Array<string>;
    /**
     * Default signing algorithm used when caller does not specify one.
     */
    defaultAlg: string;
};
type KmsProviderInfoDto = {
    /**
     * Unique provider ID (matches the id in kms.json).
     */
    name: string;
    /**
     * Type of the KMS provider (db, vault, aws-kms).
     */
    type: string;
    /**
     * Human-readable description of this provider instance.
     */
    description?: string;
    /**
     * Capabilities of this provider.
     */
    capabilities: KmsProviderCapabilitiesDto;
};
type KmsProvidersResponseDto = {
    /**
     * Detailed info for each registered KMS provider.
     */
    providers: Array<KmsProviderInfoDto>;
    /**
     * The default KMS provider name.
     */
    default: string;
};
type ProviderHealthResponseDto = {
    /**
     * KMS provider id
     */
    providerId: string;
    /**
     * KMS provider type
     */
    type: string;
    /**
     * Whether the provider health check passed
     */
    ok: boolean;
    /**
     * Health check latency in milliseconds
     */
    latencyMs?: number;
    /**
     * Optional health check error
     */
    error?: string;
};
type KmsConfigDto = {
    /**
     * ID of the default KMS provider. Defaults to "db" if not set.
     */
    defaultProvider?: string | string;
    /**
     * List of KMS provider configurations. Each provider must have a unique id and a type.
     */
    providers: Array<{
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'db';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
    } | {
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'vault';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
        /**
         * URL of the HashiCorp Vault instance. Supports ${ENV_VAR} placeholders.
         */
        vaultUrl: string | string;
        /**
         * Authentication token for HashiCorp Vault. Supports ${ENV_VAR} placeholders.
         */
        vaultToken: string | string;
    } | {
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'aws-kms';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
        /**
         * AWS region for KMS. Supports ${ENV_VAR} placeholders.
         */
        region: string | string;
        /**
         * AWS access key ID. Optional — uses SDK credential chain if not provided. Supports ${ENV_VAR} placeholders.
         */
        accessKeyId?: string | string;
        /**
         * AWS secret access key. Optional — uses SDK credential chain if not provided. Supports ${ENV_VAR} placeholders.
         */
        secretAccessKey?: string | string;
    } | {
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'pkcs11';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
        /**
         * Absolute path to the PKCS#11 module library (.so/.dll/.dylib). Supports ${ENV_VAR} placeholders.
         */
        library: string | string;
        /**
         * Slot selection. Either the numeric slot index (as a string for ENV interpolation, or a number) or the token label. Supports ${ENV_VAR} placeholders.
         */
        slot: number | string;
        /**
         * User PIN used for C_Login. Supports ${ENV_VAR} placeholders.
         */
        pin: string | string;
        /**
         * Open the PKCS#11 session in read-only mode. Defaults to false.
         */
        readOnly?: boolean;
    } | {
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'http';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
        /**
         * Base URL of the remote KMS microservice (no trailing slash). Supports ${ENV_VAR} placeholders.
         */
        baseUrl: string | string;
        /**
         * Authentication method for the remote KMS service. Supports bearer token, OAuth 2.0 client credentials, and mutual TLS. Omit (or set type to "none") for unauthenticated services.
         */
        auth?: {
            /**
             * No authentication — suitable for services on a trusted private network.
             */
            type: 'none';
        } | {
            /**
             * Static Bearer token sent as Authorization: Bearer <token>.
             */
            type: 'bearer';
            /**
             * Bearer token value. Supports ${ENV_VAR} placeholders.
             */
            token: string | string;
        } | {
            /**
             * OAuth 2.0 Client Credentials — EUDIPLO fetches and caches short-lived tokens.
             */
            type: 'oauth2-client-credentials';
            /**
             * Token endpoint URL (e.g. Keycloak, Entra ID). Supports ${ENV_VAR} placeholders.
             */
            tokenUrl: string | string;
            /**
             * OAuth 2.0 client ID. Supports ${ENV_VAR} placeholders.
             */
            clientId: string | string;
            /**
             * OAuth 2.0 client secret. Supports ${ENV_VAR} placeholders.
             */
            clientSecret: string | string;
            /**
             * Space-separated list of OAuth 2.0 scopes to request. Optional.
             */
            scope?: string | string;
        } | {
            /**
             * Mutual TLS — EUDIPLO presents a client certificate on every connection.
             */
            type: 'mtls';
            /**
             * Absolute path to the PEM-encoded client certificate file. Supports ${ENV_VAR} placeholders.
             */
            certFile: string | string;
            /**
             * Absolute path to the PEM-encoded private key file for the client certificate. Supports ${ENV_VAR} placeholders.
             */
            keyFile: string | string;
            /**
             * Absolute path to the PEM-encoded CA bundle to trust for the remote server's certificate. Omit to use the system CA store.
             */
            caFile?: string | string;
        };
        /**
         * Path prefix for key endpoints on the remote service. Defaults to /keys.
         */
        keysPath?: string | string;
        /**
         * Path for the health check endpoint on the remote service. Defaults to /health.
         */
        healthPath?: string | string;
        /**
         * Whether the remote service supports key import via POST {keysPath}/{kid}/import. Defaults to false.
         */
        canImport?: boolean;
    } | {
        /**
         * Unique identifier for this provider instance. Used when generating keys to specify which provider to use.
         */
        id: string | string;
        /**
         * Type of the KMS provider.
         */
        type: 'csc';
        /**
         * Human-readable description of this provider instance.
         */
        description?: string | string;
        /**
         * Base URL of the CSC service (without trailing slash). Supports ${ENV_VAR} placeholders.
         */
        baseUrl: string | string;
        /**
         * OAuth2 token endpoint URL for client-credentials flow. Supports ${ENV_VAR} placeholders.
         */
        tokenUrl: string | string;
        /**
         * OAuth2 client ID. Supports ${ENV_VAR} placeholders.
         */
        clientId: string | string;
        /**
         * OAuth2 client secret. Supports ${ENV_VAR} placeholders.
         */
        clientSecret: string | string;
        /**
         * OAuth2 scope to request during token acquisition.
         */
        scope?: string | string;
        /**
         * Default CSC credential ID. If omitted, the adapter calls credentials/list and picks the first entry.
         */
        credentialId?: string | string;
        /**
         * Optional CSC user ID used in credentials/list requests.
         */
        userId?: string | string;
        /**
         * CSC API path prefix appended to baseUrl. Defaults to /csc/v2.
         */
        apiPath?: string | string;
        /**
         * Hash algorithm OID for signatures/signHash and credentials/authorize. Defaults to SHA-256 OID.
         */
        hashAlgorithmOid?: string | string;
        /**
         * Signature algorithm OID for signatures/signHash. Defaults to ecdsa-with-SHA256 OID.
         */
        signAlgorithmOid?: string | string;
        /**
         * Static SAD token. If set, the adapter sends it directly in signatures/signHash requests.
         */
        sad?: string | string;
        /**
         * When true and no static SAD is provided, the adapter calls credentials/authorize to obtain SAD before signatures/signHash.
         */
        useAuthorizeEndpoint?: boolean;
        /**
         * Optional authData array passed to credentials/authorize (e.g., PIN/OTP factors).
         */
        authorizeAuthData?: Array<{
            /**
             * Authentication factor identifier expected by the CSC provider (e.g., PIN, OTP).
             */
            id: string | string;
            /**
             * Authentication factor value sent to CSC credentials/authorize.
             */
            value: string | string;
        }>;
    }>;
};
type KmsTenantConfigResponseDto = {
    /**
     * Tenant-specific KMS configuration from <CONFIG_FOLDER>/<tenantId>/kms.json. Null when no tenant file exists.
     */
    tenantConfig?: KmsConfigDto | null;
    /**
     * Effective configuration used at runtime for the tenant (global + tenant merge).
     */
    effectiveConfig: KmsConfigDto;
};
type CertificateInfoDto = {
    /**
     * Certificate in PEM format.
     */
    pem: string;
    /**
     * Certificate subject (CN).
     */
    subject?: string;
    /**
     * Certificate issuer (CN).
     */
    issuer?: string;
    /**
     * Certificate not before date.
     */
    notBefore?: string;
    /**
     * Certificate not after date.
     */
    notAfter?: string;
    /**
     * Serial number.
     */
    serialNumber?: string;
};
type PublicKeyInfoDto = {
    /**
     * Key type (e.g., EC).
     */
    kty: string;
    /**
     * Key algorithm (e.g., ES256).
     */
    alg?: string;
    /**
     * Key ID.
     */
    kid?: string;
    /**
     * Curve (for EC keys).
     */
    crv?: string;
};
type RotationPolicyResponseDto = {
    /**
     * Whether automatic key rotation is enabled.
     */
    enabled: boolean;
    /**
     * Rotation interval in days.
     */
    intervalDays?: number;
    /**
     * Certificate validity in days.
     */
    certValidityDays?: number;
    /**
     * Next scheduled rotation date.
     */
    nextRotationAt?: string;
};
type KeyChainResponseDto = {
    /**
     * Unique identifier for the key chain.
     */
    id: string;
    /**
     * Usage type of the key chain.
     */
    usageType: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    /**
     * Type of key chain (standalone or internalChain).
     */
    type: 'standalone' | 'internalChain';
    /**
     * Human-readable description.
     */
    description?: string;
    /**
     * KMS provider used for this key chain.
     */
    kmsProvider: string;
    /**
     * Root CA certificate (only for internalChain type).
     */
    rootCertificate?: CertificateInfoDto;
    /**
     * Active signing key's public key info.
     */
    activePublicKey: PublicKeyInfoDto;
    /**
     * Active signing key's certificate. Not present for encryption keys.
     */
    activeCertificate?: CertificateInfoDto;
    /**
     * Previous signing key's public key info (if in grace period).
     */
    previousPublicKey?: PublicKeyInfoDto;
    /**
     * Previous signing key's certificate (if in grace period).
     */
    previousCertificate?: CertificateInfoDto;
    /**
     * Previous key expiry date.
     */
    previousKeyExpiry?: string;
    /**
     * Rotation policy configuration.
     */
    rotationPolicy: RotationPolicyResponseDto;
    /**
     * Timestamp when the key chain was created.
     */
    createdAt: string;
    /**
     * Timestamp when the key chain was last updated.
     */
    updatedAt: string;
};
type ExportEcJwk = {
    /**
     * Key type
     */
    kty: string;
    /**
     * Curve
     */
    crv: string;
    /**
     * X coordinate (base64url)
     */
    x: string;
    /**
     * Y coordinate (base64url)
     */
    y: string;
    /**
     * Private key (base64url)
     */
    d: string;
    /**
     * Algorithm
     */
    alg?: string;
    /**
     * Key ID
     */
    kid?: string;
};
type ExportRotationPolicyDto = {
    /**
     * Whether rotation is enabled.
     */
    enabled: boolean;
    /**
     * Rotation interval in days.
     */
    intervalDays?: number;
    /**
     * Certificate validity in days.
     */
    certValidityDays?: number;
};
type KeyChainExportDto = {
    /**
     * Key chain ID.
     */
    id: string;
    /**
     * Human-readable description.
     */
    description?: string;
    /**
     * Usage type for this key chain.
     */
    usageType: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    /**
     * The private key in JWK format (EC).
     */
    key: ExportEcJwk;
    /**
     * Certificate chain in PEM format (leaf first, then intermediates/CA).
     */
    crt?: Array<string>;
    /**
     * KMS provider name.
     */
    kmsProvider?: string;
    /**
     * Rotation policy.
     */
    rotationPolicy?: ExportRotationPolicyDto;
};
type RotationPolicyCreateDto = {
    /**
     * Whether automatic key rotation is enabled.
     */
    enabled: boolean;
    /**
     * Rotation interval in days. Required when enabled is true.
     */
    intervalDays?: number;
    /**
     * Certificate validity in days. Defaults to rotation interval + 30 days grace period.
     */
    certValidityDays?: number;
};
type KeyChainCreateDto = {
    /**
     * Usage type determines the purpose of this key chain (access, attestation, etc.).
     */
    usageType: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    /**
     * Type of key chain to create.
     */
    type: 'standalone' | 'internalChain';
    /**
     * Human-readable description for the key chain.
     */
    description?: string;
    /**
     * KMS provider to use (defaults to the configured default provider).
     */
    kmsProvider?: string;
    /**
     * Rotation policy configuration. Only applicable for the signing key (root CA never rotates).
     */
    rotationPolicy?: RotationPolicyCreateDto & {
        /**
         * Enable or disable automatic key rotation.
         */
        enabled?: boolean;
        /**
         * Rotation interval in days.
         */
        intervalDays?: number;
        /**
         * Certificate validity period in days for generated leaf certificates.
         */
        certValidityDays?: number;
    };
};
type KeyChainIdResponseDto = {
    /**
     * The created or imported key chain ID
     */
    id: string;
};
type EcJwk = {
    /**
     * Key type (for example EC).
     */
    kty: string;
    /**
     * Elliptic curve public x coordinate.
     */
    x: string;
    /**
     * Elliptic curve public y coordinate.
     */
    y: string;
    /**
     * Elliptic curve name.
     */
    crv: string;
    /**
     * Private key value.
     */
    d: string;
    /**
     * Optional algorithm hint.
     */
    alg?: string;
    /**
     * Optional key identifier.
     */
    kid?: string;
};
type RotationPolicyImportDto = {
    /**
     * Whether rotation is enabled. When true, the imported key becomes a root CA signer.
     */
    enabled: boolean;
    /**
     * Rotation interval in days.
     */
    intervalDays?: number;
    /**
     * Certificate validity in days.
     */
    certValidityDays?: number;
};
type KeyChainImportDto = {
    /**
     * ID for the key chain. If not provided, a new UUID will be generated.
     */
    id?: string;
    /**
     * The private key in JWK format.
     */
    key: EcJwk & {
        /**
         * Key type (for example EC).
         */
        kty?: string;
        /**
         * Elliptic curve public x coordinate.
         */
        x?: string;
        /**
         * Elliptic curve public y coordinate.
         */
        y?: string;
        /**
         * Elliptic curve name.
         */
        crv?: string;
        /**
         * Private key value.
         */
        d?: string;
        /**
         * Optional algorithm hint.
         */
        alg?: string;
        /**
         * Optional key identifier.
         */
        kid?: string;
    };
    /**
     * Human-readable description.
     */
    description?: string;
    /**
     * Usage type for this key chain.
     */
    usageType: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    /**
     * Certificate chain (leaf first). Each entry may be PEM or base64-encoded DER; values are normalized to PEM during import. When rotationPolicy.enabled=true, the last certificate in the chain is treated as the root CA certificate.
     */
    crt?: Array<string>;
    /**
     * KMS provider to use. Defaults to 'db'.
     */
    kmsProvider?: string;
    /**
     * Rotation policy. When enabled, the imported key becomes a root CA signer and a new leaf key is generated. If crt is provided, the selected root CA certificate must have CA=true and its public key must match the imported private key.
     */
    rotationPolicy?: RotationPolicyImportDto & {
        /**
         * Enable automatic rotation for imported key chains.
         */
        enabled?: boolean;
        /**
         * Rotation interval in days.
         */
        intervalDays?: number;
        /**
         * Certificate validity period in days.
         */
        certValidityDays?: number;
    };
};
type RotationPolicyUpdateDto = {
    /**
     * Whether automatic key rotation is enabled.
     */
    enabled?: boolean;
    /**
     * Rotation interval in days.
     */
    intervalDays?: number;
    /**
     * Certificate validity in days.
     */
    certValidityDays?: number;
};
type KeyChainUpdateDto = {
    /**
     * Human-readable description for the key chain.
     */
    description?: string;
    /**
     * Rotation policy configuration.
     */
    rotationPolicy?: RotationPolicyUpdateDto & {
        /**
         * Optional replacement for rotation enabled flag.
         */
        enabled?: boolean;
        /**
         * Optional replacement for rotation interval in days.
         */
        intervalDays?: number;
        /**
         * Optional replacement for certificate validity period in days.
         */
        certValidityDays?: number;
    };
    /**
     * Active certificate chain in PEM format. Used for external certificate updates.
     */
    activeCertificate?: string;
};
type TenantEntity = {
    /**
     * Unique tenant identifier
     */
    id: string;
    /**
     * Tenant display name
     */
    name: string;
    /**
     * Tenant description
     */
    description?: string | null;
    /**
     * Tenant status
     */
    status: string;
    /**
     * Session storage configuration for this tenant. Controls TTL and cleanup behavior.
     */
    sessionConfig?: SessionStorageConfig | null;
    /**
     * Status list configuration for this tenant. Only affects newly created status lists.
     */
    statusListConfig?: StatusListConfig | null;
    /**
     * Clients associated with the tenant
     */
    clients?: Array<ClientEntity>;
};
type AttributeProviderEntity = {
    /**
     * Tenant identifier
     */
    tenantId: string;
    /**
     * Attribute provider name
     */
    name: string;
    /**
     * Attribute provider description
     */
    description?: string | null;
    /**
     * Attribute provider URL
     */
    url: string;
    auth: WebHookAuthConfigNone | WebHookAuthConfigHeader;
    id: string;
    tenant: TenantEntity;
};
type CreateAttributeProviderDto = {
    /**
     * Unique attribute provider identifier.
     */
    id: string;
    /**
     * Display name of the attribute provider.
     */
    name: string;
    /**
     * Optional attribute provider description.
     */
    description?: string | null;
    /**
     * Base URL of the attribute provider endpoint.
     */
    url: string;
    /**
     * Authentication configuration for outbound provider requests.
     */
    auth: {
        /**
         * Disable authentication for attribute provider calls.
         */
        type: 'none';
    } | {
        /**
         * Use API key authentication.
         */
        type: 'apiKey';
        /**
         * API key authentication settings.
         */
        config: {
            /**
             * HTTP header name carrying the API key.
             */
            headerName: string;
            /**
             * API key value.
             */
            value: string;
        };
    };
};
type UpdateAttributeProviderDto = {
    /**
     * Unique attribute provider identifier.
     */
    id?: string;
    /**
     * Display name of the attribute provider.
     */
    name?: string;
    /**
     * Optional attribute provider description.
     */
    description?: string | null;
    /**
     * Base URL of the attribute provider endpoint.
     */
    url?: string;
    /**
     * Authentication configuration for outbound provider requests.
     */
    auth?: {
        /**
         * Disable authentication for attribute provider calls.
         */
        type: 'none';
    } | {
        /**
         * Use API key authentication.
         */
        type: 'apiKey';
        /**
         * API key authentication settings.
         */
        config: {
            /**
             * HTTP header name carrying the API key.
             */
            headerName: string;
            /**
             * API key value.
             */
            value: string;
        };
    };
};
type AuthorizeQueries = {
    issuer_state?: string;
    response_type?: string;
    client_id?: string;
    redirect_uri?: string;
    resource?: string;
    scope?: string;
    code_challenge?: string;
    code_challenge_method?: string;
    dpop_jkt?: string;
    request_uri?: string;
    auth_session?: string;
    state?: string;
    /**
     * RFC 9396 authorization details. When passed via
     * application/x-www-form-urlencoded (PAR) the value is a JSON string; when
     * passed inside a signed request object it can already be an array.
     */
    authorization_details?: string | Array<unknown>;
};
type OfferRequestDto = {
    /**
     * The type of response expected for the offer request.
     */
    response_type: 'uri' | 'iso-18013-7' | 'dc-api';
    /**
     * Authorization server id from issuer configuration. If omitted, the first enabled server is used.
     */
    authorization_server?: string;
    /**
     * Credential claims configuration per credential. Keys must match credentialConfigurationIds.
     */
    credentialClaims?: {
        [key: string]: {
            type: 'inline';
            claims: {
                [key: string]: unknown;
            };
        } | {
            type: 'attributeProvider';
            attributeProviderId: string;
        } | {
            type: 'webhook';
            webhook: {
                url: string;
                auth?: {
                    [key: string]: unknown;
                };
            };
        };
    };
    /**
     * The flow type for the offer request.
     */
    flow: 'authorization_code' | 'pre_authorized_code';
    /**
     * Transaction code for pre-authorized code flow.
     */
    tx_code?: string;
    /**
     * Description for the transaction code (e.g., "Please enter the PIN sent to your email").
     */
    tx_code_description?: string;
    /**
     * List of credential configuration ids to be included in the offer.
     */
    credentialConfigurationIds: Array<string>;
    /**
     * ID of the webhook endpoint to notify about the status of the issuance process.
     */
    webhookEndpointId?: string;
};
type WebHookAuthConfigNone = {
    /**
     * The type of authentication used for the webhook.
     */
    type: never;
};
type ApiKeyConfig = {
    /**
     * The name of the header where the API key will be sent.
     */
    headerName: string;
    /**
     * The value of the API key to be sent in the header.
     */
    value: string;
};
type WebHookAuthConfigHeader = {
    /**
     * The type of authentication used for the webhook.
     */
    type: never;
    /**
     * Configuration for API key authentication.
     * This is required if the type is 'apiKey'.
     */
    config: ApiKeyConfig & {
        headerName?: string;
        value?: string;
    };
};
type WebhookConfig = {
    /**
     * Optional authentication configuration for the webhook.
     * If not provided, no authentication will be used.
     */
    auth: WebHookAuthConfigNone | WebHookAuthConfigHeader;
    /**
     * List of credential IDs to include raw tokens for (e.g., ['sca_credential'])
     */
    includeRawTokensFor?: Array<string>;
    /**
     * The URL to which the webhook will send notifications.
     */
    url: string;
};
type TransactionData = {
    type: string;
    credential_ids: Array<string>;
};
type Session = {
    /**
     * Status of the session.
     */
    status: 'active' | 'fetched' | 'completed' | 'expired' | 'failed';
    /**
     * Unique identifier for the session.
     */
    id: string;
    /**
     * The timestamp when the request was created.
     */
    createdAt: string;
    /**
     * The timestamp when the request was last updated.
     */
    updatedAt: string;
    /**
     * The timestamp when the request is set to expire.
     */
    expiresAt?: string;
    /**
     * Flag indicating whether to use the DC API for the presentation request.
     */
    useDcApi: boolean;
    /**
     * DC API sub-protocol: "oid4vp" (OpenID4VP via DC API) or "iso-18013-7" (org.iso.mdoc).
     * Null/undefined means the standard OID4VP flow (useDcApi=false).
     */
    dcApiProtocol?: string;
    /**
     * Browser page origin recorded at offer time for BrowserHandover session transcript.
     * Used exclusively by the ISO 18013-7 Annex C flow.
     */
    browserOrigin?: string;
    /**
     * Tenant ID for multi-tenancy support.
     */
    tenantId: string;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    authorization_code?: string;
    /**
     * Refresh token for the session - used to obtain a new access token.
     */
    refresh_token?: string;
    /**
     * Expiration timestamp for the refresh token.
     * Used to validate refresh_token grant requests.
     */
    refresh_token_expires_at?: string;
    /**
     * Request URI from the authorization request.
     */
    request_uri?: string;
    /**
     * Authorization queries associated with the session.
     * Encrypted at rest.
     */
    auth_queries?: AuthorizeQueries;
    /**
     * Credential offer object containing details about the credential offer or presentation request.
     * Encrypted at rest.
     */
    offer?: {
        [key: string]: unknown;
    } | null;
    /**
     * Offer URL for the credential offer.
     */
    offerUrl?: string;
    /**
     * Credential payload containing the offer request details.
     * Encrypted at rest - may contain sensitive claim data.
     */
    credentialPayload?: OfferRequestDto;
    /**
     * ID of the webhook endpoint to notify about issuance status.
     */
    webhookEndpointId?: string;
    /**
     * Notifications associated with the session.
     */
    notifications: Array<{
        [key: string]: unknown;
    }>;
    requestId?: string;
    /**
     * The URL of the presentation auth request.
     */
    requestUrl?: string;
    /**
     * Signed presentation auth request.
     */
    requestObject?: string;
    /**
     * Per-authorization-request private encryption key used to decrypt
     * wallet responses. Encrypted at rest.
     */
    responseEncryptionPrivateJwk?: {
        [key: string]: unknown;
    } | null;
    /**
     * Verified credentials from the presentation process.
     * Encrypted at rest - contains personal information.
     */
    credentials?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Nonce from the Verifiable Presentation request.
     */
    vp_nonce?: string;
    /**
     * Client ID used in the OID4VP authorization request.
     */
    clientId?: string;
    /**
     * Cryptographic random nonce used in wallet-facing URLs (response_uri, request_uri, state).
     * Per OID4VP spec Section 13.3, this separates the wallet-facing identifier (request-id)
     * from the frontend-facing session ID (transaction-id) to prevent session fixation.
     */
    walletNonce?: string;
    /**
     * Cryptographic random code generated after successful VP Token processing.
     * Per OID4VP spec Section 13.3, included in redirect_uri so only the legitimate
     * frontend (which receives the redirect) can confirm the session completed.
     */
    responseCode?: string;
    /**
     * Response URI used in the OID4VP authorization request.
     */
    responseUri?: string;
    /**
     * Redirect URI to which the user-agent should be redirected after the presentation is completed.
     */
    redirectUri?: string | null;
    /**
     * Where to send the claims webhook response.
     */
    parsedWebhook?: WebhookConfig;
    /**
     * Transaction data to include in the OID4VP authorization request.
     * Can be overridden per-request from the presentation configuration.
     */
    transaction_data?: Array<TransactionData>;
    /**
     * Per-session clock skew tolerance for presentation credential JWT time validation.
     */
    skewSeconds?: number;
    externalIssuer?: string;
    /**
     * Identifier of the authorization server selected when this issuance session
     * was created. Required for deterministic mapping of external AS access
     * tokens back to the correct issuance session.
     */
    authorizationServerId?: string;
    /**
     * The subject (sub) from the external authorization server token.
     * Used to identify the user at the external AS.
     */
    externalSubject?: string;
    /**
     * Error reason if the session failed.
     * Stores the error message when status is 'failed'.
     */
    errorReason?: string;
    /**
     * Machine-readable failure code when status is 'failed' (e.g.
     * `trust_chain_not_trusted`). Stable across credential and trust-list
     * formats; consumers branch on this rather than parsing {@link errorReason}.
     */
    failureCode?: string;
    /**
     * Structured verification outcome (success or failure, provenance and
     * diagnostics, per credential). Additive to {@link status} /
     * {@link errorReason}; verbose detail stays in the session log only.
     */
    outcome?: {
        [key: string]: unknown;
    } | null;
    /**
     * Number of failed tx_code (transaction code) validation attempts.
     * Used to enforce brute-force protection in the pre-authorized code flow.
     * Reset implicitly when the session is consumed successfully.
     */
    txCodeFailedAttempts: number;
    /**
     * Flag indicating whether the session offer has been consumed.
     * Prevents replay attacks by ensuring each offer can only be used once.
     * For OID4VCI: set after successful token exchange.
     * For OID4VP: set after successful response validation.
     */
    consumed: boolean;
    /**
     * Timestamp of the first consumption event for the session offer.
     * For OID4VCI this can be URI resolution or later flow completion.
     * Null if no consumption event has happened yet.
     */
    consumedAt?: string;
};
type PaginatedSessionResponseDto = {
    /**
     * The sessions for the current page.
     */
    items: Array<Session>;
    /**
     * Total number of sessions matching the query
     */
    total: number;
    /**
     * Current page number (1-based)
     */
    page: number;
    /**
     * Number of items per page
     */
    pageSize: number;
    /**
     * Total number of pages
     */
    totalPages: number;
};
type SessionLogEntryResponseDto = {
    /**
     * Log entry ID
     */
    id: string;
    /**
     * Session ID
     */
    sessionId: string;
    /**
     * Timestamp of the log entry
     */
    timestamp: string;
    /**
     * Log level
     */
    level: 'info' | 'warn' | 'error';
    /**
     * Flow stage
     */
    stage?: string;
    /**
     * Log message
     */
    message: string;
    /**
     * Additional structured detail
     */
    detail?: {
        [key: string]: unknown;
    };
};
type StatusUpdateDto = {
    /**
     * Session identifier used to locate credentials for status updates.
     */
    sessionId: string;
    /**
     * Optional credential configuration id. If omitted, all credentials linked to the session are updated.
     */
    credentialConfigurationId?: string;
    /**
     * New credential status: 0 = valid, 1 = revoked, 2 = suspended.
     */
    status: number;
};
type UpdateSessionConfigDto = {
    /**
     * Time-to-live for sessions in seconds. Set to null to use global default.
     */
    ttlSeconds?: number | null | null;
    /**
     * Cleanup mode: 'full' deletes everything, 'anonymize' keeps metadata but removes PII.
     */
    cleanupMode?: 'full' | 'anonymize';
};
type StatusListImportDto = {
    /**
     * Unique identifier for the status list
     */
    id: string;
    /**
     * Credential configuration ID to bind this list exclusively to. Leave empty for a shared list.
     */
    credentialConfigurationId?: string | null;
    /**
     * Key chain ID to use for signing. Leave empty to use the tenant's default StatusList key chain.
     */
    keyChainId?: string;
    /**
     * Capacity of the status list. If not provided, uses tenant or global defaults.
     */
    capacity?: number;
    /**
     * Bits per status value. If not provided, uses tenant or global defaults.
     */
    bits?: 1 | 2 | 4 | 8;
};
type StatusListAggregationDto = {
    /**
     * Array of status list token URIs
     */
    status_lists: Array<string>;
};
type UpdateStatusListConfigDto = {
    /**
     * The capacity of the status list. Set to null to reset to global default.
     */
    capacity?: number | null | null;
    /**
     * Bits per status entry. Set to null to reset to global default.
     */
    bits?: 1 | 2 | 4 | 8;
    /**
     * TTL in seconds for the status list JWT. Set to null to reset to global default.
     */
    ttl?: number | null | null;
    /**
     * If true, regenerate JWT on every status change. Set to null to reset to default (false).
     */
    immediateUpdate?: boolean | null;
    /**
     * If true, include aggregation_uri in status list JWTs for pre-fetching support. Set to null to reset to default (true).
     */
    enableAggregation?: boolean | null;
};
type StatusListResponseDto = {
    /**
     * Unique identifier for the status list
     */
    id: string;
    /**
     * The tenant ID
     */
    tenantId: string;
    /**
     * Credential configuration ID this list is bound to. Null means shared.
     */
    credentialConfigurationId?: string | null;
    /**
     * Key chain ID used for signing. Null means using the tenant's default.
     */
    keyChainId?: string | null;
    /**
     * Bits per status value
     */
    bits: 1 | 2 | 4 | 8;
    /**
     * Total capacity of the status list
     */
    capacity: number;
    /**
     * Number of entries in use
     */
    usedEntries: number;
    /**
     * Number of available entries
     */
    availableEntries: number;
    /**
     * The public URI for this status list
     */
    uri: string;
    /**
     * Creation timestamp
     */
    createdAt: string;
    /**
     * JWT expiration timestamp. Null if JWT has not been generated yet.
     */
    expiresAt?: string | null;
};
type CreateStatusListDto = {
    /**
     * Credential configuration ID to bind this list exclusively to. Leave empty for a shared list.
     */
    credentialConfigurationId?: string;
    /**
     * Key chain ID to use for signing. Leave empty to use the tenant's default StatusList key chain.
     */
    keyChainId?: string;
    /**
     * Bits per status value. More bits allow more status states. Defaults to tenant configuration.
     */
    bits?: 1 | 2 | 4 | 8;
    /**
     * Maximum number of credential status entries. Defaults to tenant configuration.
     */
    capacity?: number;
};
type UpdateStatusListDto = {
    /**
     * Credential configuration ID to bind this list exclusively to. Set to null to make this a shared list.
     */
    credentialConfigurationId?: string | null | null;
    /**
     * Key chain ID to use for signing. Set to null to use the tenant's default StatusList key chain.
     */
    keyChainId?: string | null | null;
};
type ClaimsQuery = {
    id?: string;
    path: Array<string>;
    values?: Array<string>;
};
type CredentialSetQuery = {
    options: Array<Array<string>>;
    required?: boolean;
};
type PolicyCredential = {
    claims?: Array<unknown>;
    credentials: Array<unknown>;
    credential_sets?: Array<unknown>;
};
type AttestationBasedPolicy = {
    policy: 'attestationBased';
    values: Array<{
        claims?: Array<unknown>;
        credentials: Array<unknown>;
        credential_sets?: Array<unknown>;
    }>;
};
type NoneTrustPolicy = {
    policy: string;
};
type AllowListPolicy = {
    policy: string;
    values: Array<string>;
};
type RootOfTrustPolicy = {
    policy: string;
    values: string;
};
type Vct = {
    vct?: string;
    name?: string;
    description?: string;
    extends?: string;
    'extends#integrity'?: string;
    schema_uri?: string;
    'schema_uri#integrity'?: string;
};
type IaeActionOpenid4VpPresentation = {
    /**
     * Action type discriminator
     */
    type: 'openid4vp_presentation';
    /**
     * ID of the presentation configuration to use for this step
     */
    presentationConfigId: string;
    label?: string;
};
type IaeActionRedirectToWeb = {
    /**
     * Action type discriminator
     */
    type: 'redirect_to_web';
    /**
     * URL to redirect the user to for web-based interaction
     */
    url: string;
    /**
     * URL where the external service should redirect back after completion. If not provided, the service must call back to the IAE endpoint.
     */
    callbackUrl?: string;
    /**
     * Description of what the user should do on the web page (for wallet display)
     */
    description?: string;
    label?: string;
};
type WebhookEndpointEntity = {
    /**
     * Unique identifier for the webhook endpoint
     */
    id: string;
    /**
     * Tenant identifier
     */
    tenantId: string;
    /**
     * Webhook endpoint name
     */
    name: string;
    /**
     * Webhook endpoint description
     */
    description?: string | null;
    /**
     * Webhook endpoint URL
     */
    url: string;
    auth: WebHookAuthConfigNone | WebHookAuthConfigHeader;
    tenant: TenantEntity;
};
type SchemaUriEntry = {
    /**
     * Credential config ID to resolve and upload its schema content. When set, uri can be omitted and is resolved server-side.
     */
    credentialConfigId?: string;
    /**
     * Attestation format this schema URI applies to (e.g. dc+sd-jwt, mso_mdoc)
     */
    format?: string;
    /**
     * URI pointing to the schema document for this format
     */
    uri?: string;
    /**
     * Schema-format specific metadata (for example { vct: 'urn:example:vct' } for dc+sd-jwt).
     */
    meta?: {
        [key: string]: unknown;
    };
};
type TrustAuthorityEntry = {
    /**
     * Trust list ID to resolve from the database. When set, frameworkType, value, and verificationMethod are derived automatically.
     */
    trustListId?: string;
    /**
     * Trust framework type (ignored when trustListId is set)
     */
    frameworkType?: 'aki' | 'etsi_tl' | 'openid_federation';
    /**
     * URI of the trust list or trust anchor (ignored when trustListId is set)
     */
    value?: string;
    /**
     * Optional verification material for external trusted authorities (for example a JWK). For internal trust-list URLs, EUDIPLO resolves verification material from the database.
     */
    verificationMethod?: {
        [key: string]: unknown;
    } | string;
};
type SchemaMetaConfig = {
    /**
     * Optional override for the schema ID (attestation identifier URI). When not set, derived from vct (dc+sd-jwt) or docType (mso_mdoc).
     */
    id?: string;
    /**
     * Human-readable name of the schema metadata entry. Required when publishing new schema metadata; optional when linking an existing schema metadata id to a credential config.
     */
    name?: string;
    /**
     * Schema version in SemVer format
     */
    version?: string;
    /**
     * URI of the Attestation Rulebook. Required when publishing new schema metadata; optional when linking an existing schema metadata id to a credential config.
     */
    rulebookURI?: string;
    /**
     * Attestation Level of Security
     */
    attestationLoS?: 'iso_18045_high' | 'iso_18045_moderate' | 'iso_18045_enhanced-basic' | 'iso_18045_basic';
    /**
     * Cryptographic binding type
     */
    bindingType?: 'claim' | 'key' | 'biometric' | 'none';
    /**
     * Schema URIs per attestation format. When omitted, the format is derived from the credential config format field.
     */
    schemaURIs?: Array<{
        credentialConfigId?: string;
        format?: string;
        uri?: string;
        meta?: {
            [key: string]: unknown;
        };
    }>;
    /**
     * Trust authorities for this attestation schema
     */
    trustedAuthorities?: Array<{
        trustListId?: string;
        frameworkType?: 'aki' | 'etsi_tl' | 'openid_federation';
        value?: string;
        verificationMethod?: {
            [key: string]: unknown;
        } | string;
    }>;
};
type EmbeddedDisclosurePolicy = {
    policy: string;
};
type KeyAttestationsRequired = {
    /**
     * List of required key storage types (e.g., iso_18045_high, iso_18045_moderate)
     */
    key_storage?: Array<string>;
    /**
     * List of required user authentication types (e.g., iso_18045_high, iso_18045_moderate)
     */
    user_authentication?: Array<string>;
};
type CredentialReusePolicy = {
    id: string;
    options?: Array<{
        details: Array<'once_only' | 'limited_time' | 'limited-time' | 'rotating-batch' | 'per-relying-party'>;
        batch_size?: number;
        reissue_trigger_unused?: number;
        reissue_trigger_lifetime_left?: number;
    }>;
};
type DisplayImage = {
    uri: string;
};
type Display = {
    name: string;
    description: string;
    locale: string;
    background_color?: string;
    text_color?: string;
    background_image?: DisplayImage;
    logo?: DisplayImage;
};
type IssuerMetadataCredentialConfig = {
    /**
     * Key attestation requirements for JWT proofs for this credential.
     * When set, this is published in proof_types_supported.jwt.key_attestations_required
     * for this specific credential configuration.
     */
    keyAttestationsRequired?: KeyAttestationsRequired;
    /**
     * Supported proof types for this credential configuration. Defaults to ['attestation', 'jwt'].
     */
    proofTypesSupported?: Array<'jwt' | 'attestation'>;
    credentialReusePolicy?: CredentialReusePolicy;
    format: 'mso_mdoc' | 'dc+sd-jwt';
    display: Array<Display>;
    scope?: string;
    /**
     * Document type for mDOC credentials (e.g., "org.iso.18013.5.1.mDL").
     * Only applicable when format is "mso_mdoc".
     */
    docType?: string;
};
type FieldDisplayDto = {
    /**
     * Display name
     */
    name: string;
    /**
     * Optional display description
     */
    description?: string;
    locale: string;
};
type ClaimFieldDefinitionDto = {
    /**
     * Path to claim value. For nested child fields this can be relative to the parent path.
     */
    path: Array<string | number | null>;
    /**
     * Claim value type
     */
    type: 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
    /**
     * Default value
     */
    defaultValue?: string | number | boolean | {
        [key: string]: unknown;
    } | Array<unknown> | null;
    /**
     * Whether claim is mandatory
     */
    mandatory?: boolean;
    /**
     * Whether claim is disclosable in SD-JWT
     */
    disclosable?: boolean;
    /**
     * Namespace for mDOC field. Optional when the namespace is already present as the first path segment.
     */
    namespace?: string;
    display?: Array<{
        locale: string;
        name: string;
        description?: string;
    }>;
    /**
     * Additional JSON schema constraints for this field
     */
    constraints?: {
        [key: string]: unknown;
    };
    /**
     * Optional nested child fields. Child paths may be specified relative to the parent field path.
     */
    children?: Array<ClaimFieldDefinitionDto>;
};
type KeyChainEntity = {
    /**
     * Unique identifier for the key chain.
     * This is the ID referenced by other entities (e.g., issuance config's signingKeyId).
     */
    id: string;
    /**
     * Tenant ID for the key chain.
     */
    tenantId: string;
    /**
     * The tenant that owns this key chain.
     */
    tenant: TenantEntity;
    /**
     * Human-readable description of the key chain.
     */
    description?: string;
    /**
     * The purpose/role of this key chain in the system.
     */
    usageType: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    /**
     * The usage type of the keys (sign or encrypt).
     */
    usage: 'sign' | 'encrypt';
    /**
     * The KMS provider used for this key chain.
     * References a configured KMS provider name.
     */
    kmsProvider: string;
    /**
     * External key identifier for cloud KMS providers.
     * This field stores the provider-specific key reference for the active signing key.
     */
    externalKeyId?: string;
    /**
     * External key identifier for cloud KMS providers for the root CA key.
     * Used when rotating internal-chain key chains backed by external KMS.
     */
    rootExternalKeyId?: string;
    rootJwk?: {
        [key: string]: unknown;
    };
    /**
     * Root CA certificate in PEM format.
     * Self-signed certificate for the root CA key.
     */
    rootCertificate?: string;
    activeJwk: {
        [key: string]: unknown;
    };
    /**
     * Certificate for the active signing key in PEM format.
     * Either CA-signed (if rootKey exists) or self-signed.
     */
    activeCertificate: string;
    rotationEnabled: boolean;
    /**
     * Rotation interval in days. Key material will be rotated after this many days.
     */
    rotationIntervalDays?: number;
    /**
     * Certificate validity in days when generating new certificates.
     */
    certValidityDays?: number;
    /**
     * Timestamp of when the key was last rotated.
     */
    lastRotatedAt?: string;
    previousJwk?: {
        [key: string]: unknown;
    };
    /**
     * Certificate for the previous signing key in PEM format.
     */
    previousCertificate?: string;
    /**
     * Expiry date for the previous key.
     * After this date, the previous key should be deleted.
     */
    previousKeyExpiry?: string;
    createdAt: string;
    /**
     * The timestamp when the key chain was last updated.
     */
    updatedAt: string;
};
/**
 * Issuer-side policy limiting the number of simultaneously active credentials per subject.
 */
type ActiveCredentialPolicy = {
    /**
     * Ensure a subject has at most one active credential of this configuration.
     */
    enabled: boolean;
    /**
     * How the subject's active credential set is tracked. Only 'internal' (pseudonymous, issuer-side) is currently supported.
     */
    tracking?: 'internal';
};
type CredentialConfig = {
    /**
     * VCT as a URI string (e.g., urn:eudi:pid:de:1) or as an object for EUDIPLO-hosted VCT
     */
    vct?: string | Vct | null;
    /**
     * List of IAE actions to execute before credential issuance
     */
    iaeActions?: Array<IaeActionOpenid4VpPresentation | IaeActionRedirectToWeb> | null;
    /**
     * TS11 schema metadata configuration for EUDI Catalogue of Attestations.
     *
     * When present, EUDIPLO can generate a SchemaMeta object per the TS11 spec
     * using the GET /issuer/credentials/:id/schema-metadata endpoint.
     *
     * The underlying TS11 specification is not yet finalized.
     */
    schemaMeta?: SchemaMetaConfig | null;
    /**
     * Embedded disclosure policy (discriminated union by `policy`).
     * The discriminator metadata is retained for OpenAPI schema generation.
     */
    embeddedDisclosurePolicy?: EmbeddedDisclosurePolicy | null;
    id: string;
    description?: string | null;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    config: IssuerMetadataCredentialConfig;
    fields: Array<ClaimFieldDefinitionDto>;
    /**
     * Reference to the attribute provider used for fetching claims.
     * Optional: if set, claims will be fetched from this provider during issuance.
     */
    attributeProviderId?: string | null;
    attributeProvider?: AttributeProviderEntity;
    /**
     * Reference to the webhook endpoint used for notifications.
     * Optional: if set, notifications will be sent to this endpoint.
     */
    webhookEndpointId?: string | null;
    webhookEndpoint?: WebhookEndpointEntity;
    keyBinding?: boolean;
    /**
     * Reference to the key chain used for signing.
     * Optional: if not specified, the default attestation key chain will be used.
     */
    keyChainId?: string;
    keyChain?: KeyChainEntity;
    statusManagement?: boolean;
    /**
     * Optional issuer-side policy limiting how many credentials of this
     * configuration a subject may hold active at once. When enabled, issuing a
     * new credential to a subject revokes that subject's previously issued
     * credentials for this configuration.
     *
     * Requires `statusManagement`, since revocation relies on status entries.
     *
     * Distinct from `credentialReusePolicy` (issuer metadata published to
     * wallets); this one is enforced by the issuer at issuance time.
     */
    activeCredentials?: ActiveCredentialPolicy | null;
    /**
     * For SD-JWT credentials: determines whether to include certificate chain (x5c)
     * or use federation-based trust (iss claim).
     * Default: "x5c" (federation must be explicitly selected)
     */
    sdJwtTrustFormat?: 'x5c' | 'federation' | null;
    lifeTime?: number;
};
type CredentialConfigCreate = {
    /**
     * VCT as a URI string (e.g., urn:eudi:pid:de:1) or as an object for EUDIPLO-hosted VCT
     */
    vct?: string | Vct | null;
    /**
     * List of IAE actions to execute before credential issuance
     */
    iaeActions?: Array<IaeActionOpenid4VpPresentation | IaeActionRedirectToWeb> | null;
    /**
     * TS11 schema metadata configuration for EUDI Catalogue of Attestations.
     *
     * When present, EUDIPLO can generate a SchemaMeta object per the TS11 spec
     * using the GET /issuer/credentials/:id/schema-metadata endpoint.
     *
     * The underlying TS11 specification is not yet finalized.
     */
    schemaMeta?: SchemaMetaConfig | null;
    /**
     * Embedded disclosure policy (discriminated union by `policy`).
     * The discriminator metadata is retained for OpenAPI schema generation.
     */
    embeddedDisclosurePolicy?: EmbeddedDisclosurePolicy | null;
    id: string;
    description?: string | null;
    config: IssuerMetadataCredentialConfig;
    fields: Array<ClaimFieldDefinitionDto>;
    /**
     * Reference to the attribute provider used for fetching claims.
     * Optional: if set, claims will be fetched from this provider during issuance.
     */
    attributeProviderId?: string | null;
    /**
     * Reference to the webhook endpoint used for notifications.
     * Optional: if set, notifications will be sent to this endpoint.
     */
    webhookEndpointId?: string | null;
    keyBinding?: boolean;
    /**
     * Reference to the key chain used for signing.
     * Optional: if not specified, the default attestation key chain will be used.
     */
    keyChainId?: string;
    statusManagement?: boolean;
    /**
     * Optional issuer-side policy limiting how many credentials of this
     * configuration a subject may hold active at once. When enabled, issuing a
     * new credential to a subject revokes that subject's previously issued
     * credentials for this configuration.
     *
     * Requires `statusManagement`, since revocation relies on status entries.
     *
     * Distinct from `credentialReusePolicy` (issuer metadata published to
     * wallets); this one is enforced by the issuer at issuance time.
     */
    activeCredentials?: ActiveCredentialPolicy | null;
    /**
     * For SD-JWT credentials: determines whether to include certificate chain (x5c)
     * or use federation-based trust (iss claim).
     * Default: "x5c" (federation must be explicitly selected)
     */
    sdJwtTrustFormat?: 'x5c' | 'federation' | null;
    lifeTime?: number;
};
type CredentialConfigUpdate = {
    /**
     * VCT as a URI string (e.g., urn:eudi:pid:de:1) or as an object for EUDIPLO-hosted VCT
     */
    vct?: string | Vct | null;
    /**
     * List of IAE actions to execute before credential issuance
     */
    iaeActions?: Array<IaeActionOpenid4VpPresentation | IaeActionRedirectToWeb> | null;
    /**
     * TS11 schema metadata configuration for EUDI Catalogue of Attestations.
     *
     * When present, EUDIPLO can generate a SchemaMeta object per the TS11 spec
     * using the GET /issuer/credentials/:id/schema-metadata endpoint.
     *
     * The underlying TS11 specification is not yet finalized.
     */
    schemaMeta?: SchemaMetaConfig | null;
    /**
     * Embedded disclosure policy (discriminated union by `policy`).
     * The discriminator metadata is retained for OpenAPI schema generation.
     */
    embeddedDisclosurePolicy?: EmbeddedDisclosurePolicy | null;
    id?: string;
    description?: string | null;
    config?: IssuerMetadataCredentialConfig;
    fields?: Array<ClaimFieldDefinitionDto>;
    /**
     * Reference to the attribute provider used for fetching claims.
     * Optional: if set, claims will be fetched from this provider during issuance.
     */
    attributeProviderId?: string | null;
    /**
     * Reference to the webhook endpoint used for notifications.
     * Optional: if set, notifications will be sent to this endpoint.
     */
    webhookEndpointId?: string | null;
    keyBinding?: boolean;
    /**
     * Reference to the key chain used for signing.
     * Optional: if not specified, the default attestation key chain will be used.
     */
    keyChainId?: string;
    statusManagement?: boolean;
    /**
     * Optional issuer-side policy limiting how many credentials of this
     * configuration a subject may hold active at once. When enabled, issuing a
     * new credential to a subject revokes that subject's previously issued
     * credentials for this configuration.
     *
     * Requires `statusManagement`, since revocation relies on status entries.
     *
     * Distinct from `credentialReusePolicy` (issuer metadata published to
     * wallets); this one is enforced by the issuer at issuance time.
     */
    activeCredentials?: ActiveCredentialPolicy | null;
    /**
     * For SD-JWT credentials: determines whether to include certificate chain (x5c)
     * or use federation-based trust (iss claim).
     * Default: "x5c" (federation must be explicitly selected)
     */
    sdJwtTrustFormat?: 'x5c' | 'federation' | null;
    lifeTime?: number;
};
type TrustListRef = {
    /**
     * Managed local trust-list identifier. When provided, verifier material is resolved server-side from the trust list key chain.
     */
    trustListId?: string;
    /**
     * Trust-list JWT URL. Required for external trust lists when trustListId is not set.
     */
    url?: string;
    /**
     * JWK used to verify trust-list JWT signatures for external trusted authority values.
     */
    verifierKey?: {
        [key: string]: unknown;
    };
    /**
     * Base64 DER-encoded X.509 certificate used to verify trust-list JWT signatures for external trusted authority values.
     */
    verifierX509Der?: string;
};
type TrustedAuthorityQueryEtsiTl = {
    type: 'etsi_tl';
    values: Array<TrustListRef>;
};
type TrustedAuthorityQueryOpenIdFederation = {
    type: 'openid_federation';
    values: Array<string>;
};
type DcSdJwtCredentialQueryMeta = {
    /**
     * VCT identifiers accepted for dc+sd-jwt credentials.
     */
    vct_values: Array<string>;
};
type MsoMdocCredentialQueryMeta = {
    /**
     * Document type identifier accepted for mso_mdoc credentials.
     */
    doctype_value: string;
};
type MsoMdocClaimsQuery = {
    /**
     * Whether the holder should be allowed to retain the claim in an mso_mdoc response.
     */
    intent_to_retain?: boolean;
    id?: string;
    path: Array<string>;
    values?: Array<string>;
};
type CredentialQueryDcSdJwt = {
    /**
     * Credential format discriminator.
     */
    format: 'dc+sd-jwt';
    /**
     * Ordered alternative claim combinations for this credential query.
     */
    claim_sets?: Array<Array<string>>;
    /**
     * Trusted authority constraints (discriminated by type) for this credential query.
     */
    trusted_authorities?: Array<TrustedAuthorityQueryEtsiTl | TrustedAuthorityQueryOpenIdFederation>;
    /**
     * dc+sd-jwt schema metadata for the requested credential.
     */
    meta: DcSdJwtCredentialQueryMeta;
    claims?: Array<ClaimsQuery>;
    id: string;
    multiple?: boolean;
};
type CredentialQueryMsoMdoc = {
    /**
     * Credential format discriminator.
     */
    format: 'mso_mdoc';
    /**
     * Ordered alternative claim combinations for this credential query.
     */
    claim_sets?: Array<Array<string>>;
    /**
     * Trusted authority constraints (discriminated by type) for this credential query.
     */
    trusted_authorities?: Array<TrustedAuthorityQueryEtsiTl | TrustedAuthorityQueryOpenIdFederation>;
    /**
     * mso_mdoc document type metadata for the requested credential.
     */
    meta: MsoMdocCredentialQueryMeta;
    claims?: Array<MsoMdocClaimsQuery>;
    id: string;
    multiple?: boolean;
};
type Dcql = {
    /**
     * Format-discriminated credential queries.
     */
    credentials?: Array<CredentialQueryDcSdJwt | CredentialQueryMsoMdoc>;
    credential_sets?: Array<CredentialSetQuery>;
};
type RegistrationCertificatePurpose = {
    lang: string;
    content: string;
};
type RegistrationCertificateBody = {
    privacy_policy?: string;
    support_uri?: string;
    intermediary?: string;
    purpose?: Array<{
        lang: string;
        content: string;
    }>;
    credentials?: Array<{
        [key: string]: unknown;
    }>;
    provided_attestations?: Array<{
        [key: string]: unknown;
    }>;
};
type RegistrationCertificateRequest = {
    /**
     * Optional registrar-side certificate identifier.
     * If provided and still valid, EUDIPLO reuses it instead of creating a new certificate.
     */
    id?: string;
    /**
     * Registration certificate creation payload.
     * This is merged with tenant-level registrar defaults when a certificate is created.
     */
    body?: RegistrationCertificateBody & {
        privacy_policy?: string;
        support_uri?: string;
        intermediary?: string;
        purpose?: Array<{
            lang: string;
            content: string;
        }>;
        credentials?: Array<{
            [key: string]: unknown;
        }>;
        provided_attestations?: Array<{
            [key: string]: unknown;
        }>;
    };
    /**
     * Optional pre-existing registration certificate JWT.
     * If provided, EUDIPLO forwards it as-is and does not create a new one.
     */
    jwt?: string;
};
type PresentationAttachment = {
    format: string;
    data: {
        [key: string]: unknown;
    };
    credential_ids?: Array<string>;
};
type PresentationConfig = {
    /**
     * Clock skew tolerance for credential JWT time validation, in seconds.
     */
    skewSeconds?: number;
    /**
     * Status list verification mode for presentations: strict (default), best_effort, or disabled.
     */
    statusCheckMode?: 'strict' | 'best_effort' | 'disabled';
    /**
     * Server-managed cache of the materialized registration certificate. Read-only; values supplied by clients are ignored.
     */
    readonly registrationCertCache?: {
        [key: string]: unknown;
    } | null;
    /**
     * Unique identifier for the VP request.
     */
    id: string;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    /**
     * Description of the presentation configuration.
     */
    description?: string | null;
    /**
     * Lifetime how long the presentation request is valid after creation, in seconds.
     */
    lifeTime?: number;
    /**
     * The DCQL query to be used for the VP request.
     */
    dcql_query: Dcql;
    transaction_data?: Array<TransactionData>;
    /**
     * The registration certificate request containing the necessary details.
     */
    registration_cert?: RegistrationCertificateRequest | null;
    /**
     * Reference to the webhook endpoint used for notifications.
     * Optional: if set, notifications will be sent to this endpoint.
     */
    webhookEndpointId?: string | null;
    /**
     * The timestamp when the VP request was created.
     */
    createdAt: string;
    /**
     * The timestamp when the VP request was last updated.
     */
    updatedAt: string;
    /**
     * Attestation that should be attached
     */
    attached?: Array<PresentationAttachment> | null;
    /**
     * Redirect URI to which the user-agent should be redirected after the presentation is completed.
     * You can use the `{sessionId}` placeholder in the URI, which will be replaced with the actual session ID.
     */
    redirectUri?: string | null;
    /**
     * Optional ID of the access certificate to use for signing the presentation request.
     * If not provided, the default access certificate for the tenant will be used.
     *
     * Note: This is intentionally NOT a TypeORM relationship because CertEntity uses
     * a composite primary key (id + tenantId), and SQLite cannot create foreign keys
     * that reference only part of a composite primary key. The relationship is handled
     * at the application level in the service layer.
     */
    accessKeyChainId?: string | null;
    /**
     * Enable reader authentication for the ISO 18013-7 Annex C (DC API) flow.
     *
     * When `true`, the DeviceRequest embeds a detached `readerAuth` COSE_Sign1
     * signed with the tenant's Access key chain (selected by
     * {@link accessKeyChainId}), letting the wallet cryptographically
     * authenticate the verifier — the mDOC equivalent of the signed request
     * object used in the OID4VP flow. Defaults to disabled (null/false).
     *
     * Only affects `response_type: "iso-18013-7"` offers.
     */
    readerAuth?: boolean | null;
};
type ResolveIssuerMetadataDto = {
    /**
     * Issuer URL or full OpenID4VCI metadata URL to resolve server-side.
     */
    issuerUrl: string;
};
type CredentialIssuerMetadataDto = {
    /**
     * The issuer identifier, typically a URL.
     */
    credential_issuer: string;
    /**
     * List of authorization servers that support the credential issuer.
     */
    authorization_servers: Array<string>;
    /**
     * The URL of the credential issuance endpoint.
     */
    credential_endpoint: string;
    /**
     * The URL of the notification endpoint for credential issuance.
     */
    notification_endpoint: string;
    batch_credential_issuance: {
        batch_size: number;
    };
    /**
     * Display information for the credentials that are getting issued.
     */
    display: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Object of credentials configurations supported by the issuer.
     */
    credential_configurations_supported: {
        [key: string]: unknown;
    };
    /**
     * The URL of the preferred authorization server.
     */
    authorization_server: string;
    /**
     * The URL of the status list aggregation endpoint.
     * Per RFC 9528 Section 9.2, enables verifiers to pre-fetch all status lists for offline validation.
     */
    status_list_aggregation_endpoint?: string;
    credential_response_encryption?: {
        alg_values_supported: Array<string>;
        enc_values_supported: Array<string>;
        encryption_required: boolean;
    };
};
type ResolveSchemaMetadataDto = {
    /**
     * Schema metadata URL to resolve server-side. The response must contain a signedJwt field.
     */
    schemaMetadataUrl: string;
};
type ResolvedSchemaMetadataSchemaUriDto = {
    /**
     * Optional format identifier
     */
    formatIdentifier?: string;
    /**
     * Schema URI
     */
    uri: string;
};
type ResolvedSchemaMetadataTrustedAuthorityDto = {
    /**
     * Trust framework type
     */
    frameworkType?: string;
    /**
     * Trust-framework-specific value
     */
    value?: string;
    /**
     * Whether the authority is LoTE
     */
    isLoTE?: boolean;
};
type ResolvedSchemaMetadataReferenceDto = {
    /**
     * Resolved reference format
     */
    format: string;
    /**
     * Resolved reference URI
     */
    uri: string;
    /**
     * Integrity hash for the reference
     */
    integrity?: string;
    /**
     * Additional metadata attached to the reference
     */
    meta?: {
        [key: string]: unknown;
    };
    /**
     * Parsed schema document for the reference
     */
    parsedSchema?: {
        [key: string]: unknown;
    };
};
type ResolvedSchemaMetadataSchemaDto = {
    /**
     * Schema metadata identifier
     */
    id: string;
    /**
     * Schema metadata version
     */
    version?: string;
    /**
     * Human-readable name
     */
    name?: string;
    /**
     * Human-readable description
     */
    description?: string;
    /**
     * Category label
     */
    category?: string;
    /**
     * Free-form tags
     */
    tags?: Array<string>;
    /**
     * Supported credential formats
     */
    supportedFormats: Array<string>;
    /**
     * Resolved schema URIs
     */
    schemaURIs: Array<ResolvedSchemaMetadataSchemaUriDto>;
    /**
     * Trusted authorities resolved from the schema metadata
     */
    trustedAuthorities: Array<ResolvedSchemaMetadataTrustedAuthorityDto>;
    /**
     * Resolved referenced schemas
     */
    resolvedReferences: Array<ResolvedSchemaMetadataReferenceDto>;
    /**
     * Derived DCQL query
     */
    dcqlQuery: {
        [key: string]: unknown;
    };
};
type ResolvedSchemaMetadataResponseDto = {
    /**
     * Signed JWT returned by the resolver
     */
    signedJwt: string;
    schema: ResolvedSchemaMetadataSchemaDto;
};
type ResolveSchemaMetadataJwtDto = {
    /**
     * Signed schema metadata JWT to resolve server-side. The JWT will be verified, resolved, and converted to DCQL.
     */
    signedJwt: string;
};
type MetadataSchemaDto = {
    /**
     * Unique identifier for this schema entry
     */
    id: string;
    /**
     * The credential format identifier
     */
    formatIdentifier: 'dc+sd-jwt' | 'mso_mdoc';
    /**
     * URI to the schema definition
     */
    uri?: string;
    /**
     * Format-specific metadata for the schema entry
     */
    meta?: {
        [key: string]: unknown;
    };
    /**
     * Subresource Integrity hash for the schema
     */
    integrity?: string;
};
type TrustAuthorityDto = {
    /**
     * Unique identifier for this trust authority entry
     */
    id: string;
    /**
     * Type of trust framework
     */
    frameworkType: 'etsi_tl';
    /**
     * URI or identifier for the trust list / authority
     */
    value: string;
    /**
     * Verification method for the trust list signature (e.g., JWK)
     */
    verificationMethod?: {
        [key: string]: unknown;
    };
};
type IssuerOfferEntryDto = {
    /**
     * URL where the user can receive a credential offer from this issuer.
     */
    credentialOfferUrl: string;
    /**
     * Human-readable description explaining when this issuer offer is relevant for the user.
     */
    description: string;
};
type AccessCertificateRefDto = {
    id: string;
    relyingPartyId: string;
    certificate: string;
    revoked: string;
    createdAt: string;
};
type SchemaMetadataResponseDto = {
    /**
     * The unique, server-assigned identifier (UUID) for the schema metadata
     */
    id: string;
    /**
     * Version of this schema metadata (SemVer)
     */
    version: string;
    /**
     * URI of the human-readable Rulebook document
     */
    rulebookURI?: string;
    /**
     * Subresource Integrity hash for the rulebook URI
     */
    rulebookIntegrity?: string;
    /**
     * Level of security (LoS) of this attestation
     */
    attestationLoS: 'iso_18045_high' | 'iso_18045_moderate' | 'iso_18045_enhanced-basic' | 'iso_18045_basic';
    /**
     * Required binding type between attestation and holder
     */
    bindingType: 'claim' | 'key' | 'biometric' | 'none';
    /**
     * Credential formats in which this attestation is available
     */
    supportedFormats: Array<'dc+sd-jwt' | 'mso_mdoc'>;
    /**
     * Format-specific schema URIs for this schema metadata
     */
    schemaURIs: Array<MetadataSchemaDto>;
    /**
     * Trust frameworks / trust anchors applicable to this schema metadata
     */
    trustedAuthorities: Array<TrustAuthorityDto>;
    /**
     * Domain category for filtering
     */
    category?: 'identity' | 'health' | 'finance' | 'education' | 'mobility' | 'employment' | 'other';
    /**
     * Free-form tags for filtering and search
     */
    tags?: Array<string>;
    /**
     * Optional human-readable schema name for UI display and filtering.
     */
    displayName?: string;
    /**
     * Issuer offer entries for this schema metadata. Each entry provides a credential offer URL and user-facing description.
     */
    issuerOffers: Array<IssuerOfferEntryDto>;
    /**
     * The original signed JWT
     */
    signedJwt: string;
    /**
     * Issuer from the JWT (`iss` claim)
     */
    issuer: string;
    /**
     * The access certificate used to sign this schema metadata
     */
    signerCertificate?: AccessCertificateRefDto;
    /**
     * Timestamp when the JWT was issued (from the `iat` claim)
     */
    issuedAt: string;
    /**
     * Server creation timestamp
     */
    createdAt: string;
    /**
     * Last update timestamp
     */
    updatedAt: string;
    /**
     * Whether this version is deprecated
     */
    deprecated: boolean;
    /**
     * Deprecation message shown to consumers
     */
    deprecationMessage?: string;
    /**
     * The version that supersedes this one
     */
    supersededByVersion?: string;
    /**
     * Timestamp when this version was marked as deprecated
     */
    deprecatedAt?: string;
};
type PresentationConfigCreateDto = {
    /**
     * Optional presentation configuration description.
     */
    description?: string | null;
    /**
     * Presentation configuration identifier.
     */
    id: string;
    /**
     * Presentation request lifetime in seconds.
     */
    lifeTime?: number;
    /**
     * Clock skew tolerance in seconds.
     */
    skewSeconds?: number;
    /**
     * Revocation/status check mode.
     */
    statusCheckMode?: 'strict' | 'best_effort' | 'disabled';
    /**
     * DCQL query defining requested credentials and claims.
     */
    dcql_query: {
        /**
         * Credential queries requested by the verifier.
         */
        credentials: Array<{
            /**
             * Credential query identifier.
             */
            id: string;
            /**
             * Allow multiple matching credentials.
             */
            multiple?: boolean;
            /**
             * Optional claim set constraints.
             */
            claim_sets?: Array<Array<string>>;
            /**
             * Optional trusted authority constraints.
             */
            trusted_authorities?: Array<{
                /**
                 * Trusted authority type discriminator for ETSI trust lists.
                 */
                type: 'etsi_tl';
                /**
                 * Trust list references for ETSI TL verification.
                 */
                values: Array<{
                    /**
                     * Optional trust list id reference.
                     */
                    trustListId?: string;
                    /**
                     * Optional trust list URL reference.
                     */
                    url?: string | string;
                    /**
                     * Optional verifier key material.
                     */
                    verifierKey?: {
                        [key: string]: unknown;
                    };
                    /**
                     * Optional verifier certificate in DER/base64 form.
                     */
                    verifierX509Der?: string;
                }>;
            } | {
                /**
                 * Trusted authority type discriminator for OpenID Federation.
                 */
                type: 'openid_federation';
                /**
                 * OpenID Federation authority identifiers.
                 */
                values: Array<string>;
            }>;
            /**
             * Credential format discriminator.
             */
            format: 'dc+sd-jwt';
            meta: {
                /**
                 * Accepted VCT values.
                 */
                vct_values: Array<string>;
            };
            /**
             * Optional claim-level constraints.
             */
            claims?: Array<{
                /**
                 * Optional claim query id.
                 */
                id?: string;
                /**
                 * Path to the claim value in presented credentials.
                 */
                path: Array<string | number>;
                /**
                 * Optional allowed values for the claim.
                 */
                values?: Array<string>;
            }>;
        } | {
            /**
             * Credential query identifier.
             */
            id: string;
            /**
             * Allow multiple matching credentials.
             */
            multiple?: boolean;
            /**
             * Optional claim set constraints.
             */
            claim_sets?: Array<Array<string>>;
            /**
             * Optional trusted authority constraints.
             */
            trusted_authorities?: Array<{
                /**
                 * Trusted authority type discriminator for ETSI trust lists.
                 */
                type: 'etsi_tl';
                /**
                 * Trust list references for ETSI TL verification.
                 */
                values: Array<{
                    /**
                     * Optional trust list id reference.
                     */
                    trustListId?: string;
                    /**
                     * Optional trust list URL reference.
                     */
                    url?: string | string;
                    /**
                     * Optional verifier key material.
                     */
                    verifierKey?: {
                        [key: string]: unknown;
                    };
                    /**
                     * Optional verifier certificate in DER/base64 form.
                     */
                    verifierX509Der?: string;
                }>;
            } | {
                /**
                 * Trusted authority type discriminator for OpenID Federation.
                 */
                type: 'openid_federation';
                /**
                 * OpenID Federation authority identifiers.
                 */
                values: Array<string>;
            }>;
            /**
             * Credential format discriminator.
             */
            format: 'mso_mdoc';
            meta: {
                /**
                 * Expected mDoc doctype value.
                 */
                doctype_value: string;
            };
            /**
             * Optional mDoc claim-level constraints.
             */
            claims?: Array<{
                /**
                 * Optional claim query id.
                 */
                id?: string;
                /**
                 * Path to the claim value in presented credentials.
                 */
                path: Array<string | number>;
                /**
                 * Optional allowed values for the claim.
                 */
                values?: Array<string>;
                /**
                 * Whether relying party intends to retain the claim.
                 */
                intent_to_retain?: boolean;
            }>;
        }>;
        /**
         * Optional higher-level credential set requirements.
         */
        credential_sets?: Array<{
            /**
             * Alternative credential query id combinations.
             */
            options: Array<Array<string>>;
            /**
             * Whether this credential set is mandatory.
             */
            required?: boolean;
        }>;
    };
    /**
     * Optional transaction data descriptors.
     */
    transaction_data?: Array<{
        /**
         * Transaction data type identifier.
         */
        type: string;
        /**
         * Credential query ids this transaction data applies to.
         */
        credential_ids: Array<string>;
        /**
         * Transaction details. Required for TS12 SCA transaction data.
         */
        payload?: unknown;
        [key: string]: unknown;
    }> | null;
    /**
     * Optional registration certificate request settings.
     */
    registration_cert?: {
        id?: string;
        body?: {
            privacy_policy?: string;
            support_uri?: string;
            intermediary?: string;
            purpose?: Array<{
                lang: string;
                content: string;
            }>;
            credentials?: Array<{
                [key: string]: unknown;
            }>;
            provided_attestations?: Array<{
                [key: string]: unknown;
            }>;
        };
        jwt?: string;
    } | null;
    /**
     * Optional imported registration certificate JWT.
     */
    registrationCertImportJwt?: Array<string>;
    /**
     * Optional registrar-side registration certificate id.
     */
    registrationCertImportId?: Array<string>;
    /**
     * Optional registration certificate privacy policy URI.
     */
    registrationCertBodyPrivacyPolicy?: Array<string>;
    /**
     * Optional registration certificate support URI.
     */
    registrationCertBodySupportUri?: Array<string>;
    /**
     * Optional registration certificate intermediary.
     */
    registrationCertBodyIntermediary?: Array<string>;
    /**
     * Optional registration certificate purpose entries.
     */
    registrationCertBodyPurpose?: Array<{
        lang?: string;
        content?: string;
    }> | null;
    /**
     * Optional webhook endpoint id for presentation callbacks.
     */
    webhookEndpointId?: Array<string>;
    /**
     * Optional attachments included with presentation requests.
     */
    attached?: Array<{
        /**
         * Attachment format identifier.
         */
        format: string;
        /**
         * Attachment payload.
         */
        data: unknown;
        /**
         * Optional credential query ids bound to this attachment.
         */
        credential_ids?: Array<string>;
    }> | null;
    /**
     * Optional redirect URI after presentation completion.
     */
    redirectUri?: Array<string>;
    /**
     * Optional key chain id for access token/auth operations.
     */
    accessKeyChainId?: Array<string>;
    /**
     * Whether reader authentication is required for mDoc requests.
     */
    readerAuth?: Array<boolean>;
};
type PresentationConfigUpdateDto = {
    /**
     * Optional presentation configuration description.
     */
    description?: string | null;
    /**
     * Presentation configuration identifier.
     */
    id?: string;
    /**
     * Presentation request lifetime in seconds.
     */
    lifeTime?: number;
    /**
     * Clock skew tolerance in seconds.
     */
    skewSeconds?: number;
    /**
     * Revocation/status check mode.
     */
    statusCheckMode?: 'strict' | 'best_effort' | 'disabled';
    /**
     * DCQL query defining requested credentials and claims.
     */
    dcql_query?: {
        /**
         * Credential queries requested by the verifier.
         */
        credentials: Array<{
            /**
             * Credential query identifier.
             */
            id: string;
            /**
             * Allow multiple matching credentials.
             */
            multiple?: boolean;
            /**
             * Optional claim set constraints.
             */
            claim_sets?: Array<Array<string>>;
            /**
             * Optional trusted authority constraints.
             */
            trusted_authorities?: Array<{
                /**
                 * Trusted authority type discriminator for ETSI trust lists.
                 */
                type: 'etsi_tl';
                /**
                 * Trust list references for ETSI TL verification.
                 */
                values: Array<{
                    /**
                     * Optional trust list id reference.
                     */
                    trustListId?: string;
                    /**
                     * Optional trust list URL reference.
                     */
                    url?: string | string;
                    /**
                     * Optional verifier key material.
                     */
                    verifierKey?: {
                        [key: string]: unknown;
                    };
                    /**
                     * Optional verifier certificate in DER/base64 form.
                     */
                    verifierX509Der?: string;
                }>;
            } | {
                /**
                 * Trusted authority type discriminator for OpenID Federation.
                 */
                type: 'openid_federation';
                /**
                 * OpenID Federation authority identifiers.
                 */
                values: Array<string>;
            }>;
            /**
             * Credential format discriminator.
             */
            format: 'dc+sd-jwt';
            meta: {
                /**
                 * Accepted VCT values.
                 */
                vct_values: Array<string>;
            };
            /**
             * Optional claim-level constraints.
             */
            claims?: Array<{
                /**
                 * Optional claim query id.
                 */
                id?: string;
                /**
                 * Path to the claim value in presented credentials.
                 */
                path: Array<string | number>;
                /**
                 * Optional allowed values for the claim.
                 */
                values?: Array<string>;
            }>;
        } | {
            /**
             * Credential query identifier.
             */
            id: string;
            /**
             * Allow multiple matching credentials.
             */
            multiple?: boolean;
            /**
             * Optional claim set constraints.
             */
            claim_sets?: Array<Array<string>>;
            /**
             * Optional trusted authority constraints.
             */
            trusted_authorities?: Array<{
                /**
                 * Trusted authority type discriminator for ETSI trust lists.
                 */
                type: 'etsi_tl';
                /**
                 * Trust list references for ETSI TL verification.
                 */
                values: Array<{
                    /**
                     * Optional trust list id reference.
                     */
                    trustListId?: string;
                    /**
                     * Optional trust list URL reference.
                     */
                    url?: string | string;
                    /**
                     * Optional verifier key material.
                     */
                    verifierKey?: {
                        [key: string]: unknown;
                    };
                    /**
                     * Optional verifier certificate in DER/base64 form.
                     */
                    verifierX509Der?: string;
                }>;
            } | {
                /**
                 * Trusted authority type discriminator for OpenID Federation.
                 */
                type: 'openid_federation';
                /**
                 * OpenID Federation authority identifiers.
                 */
                values: Array<string>;
            }>;
            /**
             * Credential format discriminator.
             */
            format: 'mso_mdoc';
            meta: {
                /**
                 * Expected mDoc doctype value.
                 */
                doctype_value: string;
            };
            /**
             * Optional mDoc claim-level constraints.
             */
            claims?: Array<{
                /**
                 * Optional claim query id.
                 */
                id?: string;
                /**
                 * Path to the claim value in presented credentials.
                 */
                path: Array<string | number>;
                /**
                 * Optional allowed values for the claim.
                 */
                values?: Array<string>;
                /**
                 * Whether relying party intends to retain the claim.
                 */
                intent_to_retain?: boolean;
            }>;
        }>;
        /**
         * Optional higher-level credential set requirements.
         */
        credential_sets?: Array<{
            /**
             * Alternative credential query id combinations.
             */
            options: Array<Array<string>>;
            /**
             * Whether this credential set is mandatory.
             */
            required?: boolean;
        }>;
    };
    /**
     * Optional transaction data descriptors.
     */
    transaction_data?: Array<{
        /**
         * Transaction data type identifier.
         */
        type: string;
        /**
         * Credential query ids this transaction data applies to.
         */
        credential_ids: Array<string>;
        /**
         * Transaction details. Required for TS12 SCA transaction data.
         */
        payload?: unknown;
        [key: string]: unknown;
    }> | null;
    /**
     * Optional registration certificate request settings.
     */
    registration_cert?: {
        id?: string;
        body?: {
            privacy_policy?: string;
            support_uri?: string;
            intermediary?: string;
            purpose?: Array<{
                lang: string;
                content: string;
            }>;
            credentials?: Array<{
                [key: string]: unknown;
            }>;
            provided_attestations?: Array<{
                [key: string]: unknown;
            }>;
        };
        jwt?: string;
    } | null;
    /**
     * Optional imported registration certificate JWT.
     */
    registrationCertImportJwt?: Array<string>;
    /**
     * Optional registrar-side registration certificate id.
     */
    registrationCertImportId?: Array<string>;
    /**
     * Optional registration certificate privacy policy URI.
     */
    registrationCertBodyPrivacyPolicy?: Array<string>;
    /**
     * Optional registration certificate support URI.
     */
    registrationCertBodySupportUri?: Array<string>;
    /**
     * Optional registration certificate intermediary.
     */
    registrationCertBodyIntermediary?: Array<string>;
    /**
     * Optional registration certificate purpose entries.
     */
    registrationCertBodyPurpose?: Array<{
        lang?: string;
        content?: string;
    }> | null;
    /**
     * Optional webhook endpoint id for presentation callbacks.
     */
    webhookEndpointId?: Array<string>;
    /**
     * Optional attachments included with presentation requests.
     */
    attached?: Array<{
        /**
         * Attachment format identifier.
         */
        format: string;
        /**
         * Attachment payload.
         */
        data: unknown;
        /**
         * Optional credential query ids bound to this attachment.
         */
        credential_ids?: Array<string>;
    }> | null;
    /**
     * Optional redirect URI after presentation completion.
     */
    redirectUri?: Array<string>;
    /**
     * Optional key chain id for access token/auth operations.
     */
    accessKeyChainId?: Array<string>;
    /**
     * Whether reader authentication is required for mDoc requests.
     */
    readerAuth?: Array<boolean>;
};
type TrustListEntityInfo = {
    name: string;
    lang?: string;
    uri?: string;
    country?: string;
    locality?: string;
    postalCode?: string;
    streetAddress?: string;
    contactUri?: string;
};
type InternalTrustListEntity = {
    type: 'internal';
    /**
     * Provider role published in the trust list.
     */
    providerType?: 'attestation-provider' | 'wallet-provider';
    issuerKeyChainId: string;
    revocationKeyChainId: string;
    info: TrustListEntityInfo;
};
type ExternalTrustListEntity = {
    type: 'external';
    /**
     * Provider role published in the trust list.
     */
    providerType?: 'attestation-provider' | 'wallet-provider';
    issuerCertPem: string;
    revocationCertPem: string;
    info: TrustListEntityInfo;
};
type TrustListCreateDto = {
    description?: string;
    /**
     * The full trust list JSON (generated LoTE structure)
     */
    data?: {
        [key: string]: unknown;
    };
    entities: Array<InternalTrustListEntity | ExternalTrustListEntity>;
    id?: string;
    keyChainId?: string;
};
type TrustList = {
    /**
     * Unique identifier for the trust list
     */
    id: string;
    description?: string;
    /**
     * The tenant ID for which the VP request is made.
     */
    tenantId: string;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    keyChainId: string;
    keyChain: KeyChainEntity;
    /**
     * The full trust list JSON (generated LoTE structure)
     */
    data?: {
        [key: string]: unknown;
    };
    /**
     * The original entity configuration used to create this trust list.
     * Stored for round-tripping when editing.
     */
    entityConfig?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * The sequence number for versioning (incremented on updates)
     */
    sequenceNumber: number;
    /**
     * The signed JWT representation of this trust list
     */
    jwt: string;
    createdAt: string;
    updatedAt: string;
};
type TrustListVersion = {
    id: string;
    trustListId: string;
    trustList: TrustList;
    tenantId: string;
    /**
     * The sequence number at the time this version was created
     */
    sequenceNumber: number;
    /**
     * The full trust list JSON at this version
     */
    data: {
        [key: string]: unknown;
    };
    /**
     * The entity configuration at this version
     */
    entityConfig?: {
        [key: string]: unknown;
    };
    /**
     * The signed JWT at this version
     */
    jwt: string;
    createdAt: string;
};
type TrustListCacheStatsDto = {
    /**
     * Whether the trust list cache is populated
     */
    hasCache: boolean;
};
type StatusListCacheStatsDto = {
    /**
     * Number of cached status list entries
     */
    size: number;
    /**
     * Number of cached JWT status list entries
     */
    jwtCacheSize: number;
    /**
     * Cached status list URIs
     */
    uris: Array<string>;
};
type CacheStatsResponseDto = {
    trustListCache: TrustListCacheStatsDto;
    statusListCache: StatusListCacheStatsDto;
};
type AuthenticationMethodNone = {
    method: 'none';
};
type AuthenticationUrlConfig = {
    /**
     * The URL used in the OID4VCI authorized code flow.
     * This URL is where users will be redirected for authentication.
     */
    url: string;
    /**
     * Optional webhook configuration for authentication callbacks
     */
    webhook?: WebhookConfig & {
        url?: string;
        auth?: {
            type: 'none';
        } | {
            type: 'apiKey';
            config: {
                headerName: string;
                value: string;
            };
        };
        includeRawTokensFor?: Array<string>;
    };
};
type AuthenticationMethodAuth = {
    method: 'auth';
    config: AuthenticationUrlConfig & {
        url?: string;
        webhook?: {
            url: string;
            auth: {
                type: 'none';
            } | {
                type: 'apiKey';
                config: {
                    headerName: string;
                    value: string;
                };
            };
            includeRawTokensFor?: Array<string>;
        };
    };
};
type PresentationDuringIssuanceConfig = {
    /**
     * Link to the presentation configuration that is relevant for the issuance process
     */
    type: string;
};
type AuthenticationMethodPresentation = {
    method: 'presentationDuringIssuance';
    config: PresentationDuringIssuanceConfig & {
        type?: string;
    };
};
type ManagedAuthorizationServerConfig = {
    /**
     * Authorization server implementation type
     */
    type: 'external' | 'oid4vp' | 'chained' | 'built-in';
    /**
     * Unique identifier for this authorization server
     */
    id: string;
    /**
     * Human-friendly label for the UI
     */
    label?: string;
    /**
     * Whether this managed authorization server is enabled
     */
    enabled?: boolean;
};
type ExternalAuthorizationServerConfig = {
    /**
     * Authorization server implementation type
     */
    type: 'external';
    /**
     * Unique identifier for this authorization server
     */
    id: string;
    /**
     * Issuer URL for external authorization servers
     */
    issuer: string;
    sessionBinding?: {
        method: string;
        claim: string;
    };
    label?: string;
    enabled?: boolean;
};
type ChainedAsTokenConfig = {
    /**
     * Access token lifetime in seconds
     */
    lifetimeSeconds?: number;
    /**
     * Key ID for token signing
     */
    signingKeyId?: string;
    /**
     * Whether refresh tokens should be issued
     */
    refreshTokenEnabled?: boolean;
    /**
     * Refresh token lifetime in seconds
     */
    refreshTokenExpiresInSeconds?: number;
};
type WalletProviderTrustListRefDto = {
    /**
     * Managed trust-list ID in this tenant; resolves URL and signing certificate automatically.
     */
    trustListId?: string;
    url?: string;
    /**
     * JWK used to verify the trust-list JWT signature.
     */
    verifierKey?: {
        [key: string]: unknown;
    };
    /**
     * Base64 DER-encoded X.509 certificate used to verify the trust-list JWT signature.
     */
    verifierX509Der?: string;
};
type Oid4VpAuthorizationServerConfig = {
    /**
     * Authorization server implementation type
     */
    type: 'oid4vp';
    /**
     * Stable identifier used in the AS URL path
     */
    id: string;
    /**
     * Presentation configuration ID to use for OID4VP
     */
    presentationConfigId: string;
    /**
     * Immediately redirect the browser into the wallet OID4VP request
     */
    immediateWalletRedirect?: boolean;
    /**
     * Token configuration for this authorization server
     */
    token?: ChainedAsTokenConfig & {
        lifetimeSeconds?: number;
        signingKeyId?: string;
        refreshTokenEnabled?: boolean;
        refreshTokenExpiresInSeconds?: number;
    };
    /**
     * Require DPoP for token requests issued by this authorization server
     */
    requireDPoP?: boolean;
    /**
     * Require wallet attestation for requests to this authorization server. Omit to inherit the issuance default.
     */
    walletAttestationRequired?: boolean;
    /**
     * Wallet authentication trust lists for this authorization server. Omit to inherit shared issuance trust; an empty array rejects presented attestations.
     */
    walletProviderTrustLists?: Array<{
        trustListId?: string;
        url?: string;
        verifierKey?: {
            [key: string]: unknown;
        };
        verifierX509Der?: string;
    }>;
    label?: string;
    enabled?: boolean;
};
type UpstreamOidcConfig = {
    /**
     * The OIDC issuer URL of the upstream provider
     */
    issuer: string;
    /**
     * The client ID registered with the upstream provider
     */
    clientId: string;
    /**
     * The client secret for confidential clients
     */
    clientSecret?: string;
    /**
     * Scopes to request from the upstream provider
     */
    scopes?: Array<string>;
};
type ChainedAuthorizationServerConfig = {
    /**
     * Authorization server implementation type
     */
    type: 'chained';
    /**
     * Unique identifier for this authorization server
     */
    id: string;
    /**
     * Upstream OIDC provider configuration for chained mode
     */
    upstream: UpstreamOidcConfig & {
        issuer?: string;
        clientId?: string;
        clientSecret?: string;
        scopes?: Array<string>;
    };
    /**
     * Token configuration for this authorization server
     */
    token?: ChainedAsTokenConfig & {
        lifetimeSeconds?: number;
        signingKeyId?: string;
        refreshTokenEnabled?: boolean;
        refreshTokenExpiresInSeconds?: number;
    };
    /**
     * Require DPoP for token requests issued by this authorization server
     */
    requireDPoP?: boolean;
    /**
     * Require wallet attestation for requests to this authorization server. Omit to inherit the issuance default.
     */
    walletAttestationRequired?: boolean;
    /**
     * Wallet authentication trust lists for this authorization server. Omit to inherit shared issuance trust; an empty array rejects presented attestations.
     */
    walletProviderTrustLists?: Array<{
        trustListId?: string;
        url?: string;
        verifierKey?: {
            [key: string]: unknown;
        };
        verifierX509Der?: string;
    }>;
    label?: string;
    enabled?: boolean;
};
type BuiltInAuthorizationServerConfig = {
    /**
     * Authorization server implementation type
     */
    type: 'built-in';
    /**
     * Unique identifier for this authorization server
     */
    id: string;
    /**
     * Token configuration for this authorization server
     */
    token?: ChainedAsTokenConfig & {
        lifetimeSeconds?: number;
        signingKeyId?: string;
        refreshTokenEnabled?: boolean;
        refreshTokenExpiresInSeconds?: number;
    };
    /**
     * Require DPoP for token requests issued by this authorization server
     */
    requireDPoP?: boolean;
    /**
     * Require wallet attestation for requests to this authorization server. Omit to inherit the issuance default.
     */
    walletAttestationRequired?: boolean;
    /**
     * Wallet authentication trust lists for this authorization server. Omit to inherit shared issuance trust; an empty array rejects presented attestations.
     */
    walletProviderTrustLists?: Array<{
        trustListId?: string;
        url?: string;
        verifierKey?: {
            [key: string]: unknown;
        };
        verifierX509Der?: string;
    }>;
    label?: string;
    enabled?: boolean;
};
type FederationTrustAnchorConfig = {
    /**
     * Entity identifier (sub) of the federation trust anchor.
     */
    entityId: string;
    /**
     * Federation endpoint URL for the trust anchor entity configuration.
     */
    entityConfigurationUri: string;
};
type FederationConfig = {
    /**
     * Role this tenant plays in the OpenID Federation topology.
     */
    role?: 'trust_anchor' | 'intermediate' | 'leaf';
    /**
     * Trust decision strategy when both LoTE trust lists and OpenID Federation are configured.
     */
    mode?: 'federation-only' | 'hybrid';
    /**
     * Entity identifier of this issuer/verifier in the federation.
     */
    entityId?: string;
    /**
     * Whether federation checks are enforced for upstream metadata and signer trust decisions.
     */
    enforceSigningPolicy?: boolean;
    /**
     * Cache TTL in seconds for federation entity statements and trust chain results.
     */
    cacheTtlSeconds?: number;
    /**
     * Configured federation trust anchors.
     */
    trustAnchors: Array<{
        entityId: string;
        entityConfigurationUri: string;
    }>;
};
type IssuerRegistrationCertificateConfig = {
    /**
     * Enable inclusion of a registration certificate in credential issuer metadata.
     */
    enabled?: boolean;
    /**
     * import: use an existing JWT, generate: create via registrar using attestation data derived from configured credential configurations.
     */
    mode?: 'import' | 'generate';
    /**
     * Existing registration certificate JWT used when mode is import.
     */
    jwt?: string;
    /**
     * Privacy policy URL used when generating a registration certificate (optional if registrar defaults are configured).
     */
    privacyPolicy?: string;
    /**
     * Support URI used when generating a registration certificate (optional if registrar defaults are configured).
     */
    supportUri?: string;
};
type IssuerRegistrationCertificateCache = {
    /**
     * Cached registration certificate JWT generated by EUDIPLO.
     */
    readonly jwt?: string;
    /**
     * Config fingerprint used to detect cache invalidation.
     */
    readonly fingerprint?: string;
    /**
     * JWT iat claim, seconds since epoch.
     */
    readonly issuedAt?: number;
    /**
     * JWT exp claim, seconds since epoch.
     */
    readonly expiresAt?: number;
};
type DisplayLogo = {
    uri: string;
    alt_text?: string;
};
type DisplayInfo = {
    name?: string;
    locale?: string;
    logo?: DisplayLogo & {
        uri?: string;
        alt_text?: string;
        [key: string]: unknown;
    };
};
type IssuanceConfig = {
    /**
     * Shared wallet provider trust lists for key attestations at the credential endpoint
     * and default wallet-attestation trust at managed authorization servers.
     * Each entry MUST include either `verifierKey` or `verifierX509Der`.
     */
    walletProviderTrustLists?: Array<WalletProviderTrustListRefDto>;
    /**
     * Key ID for signing access tokens. If unset, the default signing key is used.
     */
    signingKeyId?: string;
    /**
     * Dedicated managed authorization servers hosted by this issuer. At least one entry is required.
     */
    authorizationServers: Array<ExternalAuthorizationServerConfig | Oid4VpAuthorizationServerConfig | ChainedAuthorizationServerConfig | BuiltInAuthorizationServerConfig>;
    /**
     * Optional OpenID Federation configuration used for trust evaluation.
     * When omitted, trust checks rely on existing LoTE trust-list behavior.
     */
    federation?: FederationConfig | null;
    /**
     * Optional registration certificate configuration for issuer metadata (`issuer_info`).
     * Supports importing an existing JWT or generating one via registrar.
     */
    registrationCertificate?: IssuerRegistrationCertificateConfig | null;
    /**
     * Server-managed cache for generated issuer registration certificates.
     */
    readonly registrationCertificateCache?: IssuerRegistrationCertificateCache | null;
    /**
     * Whether the OID4VCI notification endpoint is exposed for this issuance configuration.
     */
    notificationEndpointEnabled?: boolean;
    /**
     * Whether `credential_response_encryption` should be advertised in the credential issuer metadata.
     */
    credentialResponseEncryption?: boolean;
    /**
     * Whether `credential_request_encryption` should be advertised in the credential issuer metadata.
     */
    credentialRequestEncryption?: boolean;
    /**
     * Maximum failed tx_code attempts before the pre-authorized code is invalidated. Defaults to 5.
     */
    txCodeMaxAttempts?: number | null;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    /**
     * Value to determine the amount of credentials that are issued in a batch.
     * Default is 1.
     */
    batchSize?: number;
    /**
     * Indicates whether DPoP is required for the issuance process. Default value is true.
     */
    dPopRequired?: boolean;
    /**
     * Default wallet attestation requirement for managed authorization servers.
     * When enabled, wallets must provide OAuth-Client-Attestation headers.
     * Default value is false.
     */
    walletAttestationRequired?: boolean;
    display: Array<DisplayInfo>;
    /**
     * The timestamp when the VP request was created.
     */
    createdAt: string;
    /**
     * The timestamp when the VP request was last updated.
     */
    updatedAt: string;
};
type UpdateIssuanceDto = {
    /**
     * Shared wallet provider trust lists for key attestations at the credential endpoint
     * and default wallet-attestation trust at managed authorization servers.
     * Each entry MUST include either `verifierKey` or `verifierX509Der`.
     */
    walletProviderTrustLists?: Array<WalletProviderTrustListRefDto>;
    /**
     * Key ID for signing access tokens. If unset, the default signing key is used.
     */
    signingKeyId?: string;
    /**
     * Dedicated managed authorization servers hosted by this issuer. At least one entry is required.
     */
    authorizationServers?: Array<ExternalAuthorizationServerConfig | Oid4VpAuthorizationServerConfig | ChainedAuthorizationServerConfig | BuiltInAuthorizationServerConfig>;
    /**
     * Optional OpenID Federation configuration used for trust evaluation.
     * When omitted, trust checks rely on existing LoTE trust-list behavior.
     */
    federation?: FederationConfig | null;
    /**
     * Optional registration certificate configuration for issuer metadata (`issuer_info`).
     * Supports importing an existing JWT or generating one via registrar.
     */
    registrationCertificate?: IssuerRegistrationCertificateConfig | null;
    /**
     * Server-managed cache for generated issuer registration certificates.
     */
    readonly registrationCertificateCache?: IssuerRegistrationCertificateCache | null;
    /**
     * Whether the OID4VCI notification endpoint is exposed for this issuance configuration.
     */
    notificationEndpointEnabled?: boolean;
    /**
     * Whether `credential_response_encryption` should be advertised in the credential issuer metadata.
     */
    credentialResponseEncryption?: boolean;
    /**
     * Whether `credential_request_encryption` should be advertised in the credential issuer metadata.
     */
    credentialRequestEncryption?: boolean;
    /**
     * Maximum failed tx_code attempts before the pre-authorized code is invalidated. Defaults to 5.
     */
    txCodeMaxAttempts?: number | null;
    /**
     * Value to determine the amount of credentials that are issued in a batch.
     * Default is 1.
     */
    batchSize?: number;
    /**
     * Indicates whether DPoP is required for the issuance process. Default value is true.
     */
    dPopRequired?: boolean;
    /**
     * Default wallet attestation requirement for managed authorization servers.
     * When enabled, wallets must provide OAuth-Client-Attestation headers.
     * Default value is false.
     */
    walletAttestationRequired?: boolean;
    display?: Array<DisplayInfo>;
};
type SignSchemaMetaConfigDto = {
    /**
     * The schema metadata configuration to submit. Registrar builds and signs the final schema metadata.
     */
    config: SchemaMetaConfig & {
        id?: string;
        name?: string;
        version?: string;
        rulebookURI?: string;
        attestationLoS?: 'iso_18045_high' | 'iso_18045_moderate' | 'iso_18045_enhanced-basic' | 'iso_18045_basic';
        bindingType?: 'claim' | 'key' | 'biometric' | 'none';
        schemaURIs?: Array<{
            credentialConfigId?: string;
            format?: string;
            uri?: string;
            meta?: {
                [key: string]: unknown;
            };
        }>;
        trustedAuthorities?: Array<{
            trustListId?: string;
            frameworkType?: 'aki' | 'etsi_tl' | 'openid_federation';
            value?: string;
            verificationMethod?: {
                [key: string]: unknown;
            } | string;
        }>;
    };
    /**
     * ID of the credential config to link back after submission. When provided, schemaMeta.id on the credential config is updated with the reserved attestation ID.
     */
    credentialConfigId?: string;
    /**
     * How to update credential config pinning after publish. keep_current: do not change existing pin (unless empty). update_to_new_version: update pinned version under current id. replace_id: repoint pin to a different schema id.
     */
    pinMode?: 'keep_current' | 'update_to_new_version' | 'replace_id';
};
type SignVersionSchemaMetaConfigDto = {
    /**
     * The schema metadata configuration to submit as a new version. Must include the existing id.
     */
    config: SchemaMetaConfig & {
        id?: string;
        name?: string;
        version?: string;
        rulebookURI?: string;
        attestationLoS?: 'iso_18045_high' | 'iso_18045_moderate' | 'iso_18045_enhanced-basic' | 'iso_18045_basic';
        bindingType?: 'claim' | 'key' | 'biometric' | 'none';
        schemaURIs?: Array<{
            credentialConfigId?: string;
            format?: string;
            uri?: string;
            meta?: {
                [key: string]: unknown;
            };
        }>;
        trustedAuthorities?: Array<{
            trustListId?: string;
            frameworkType?: 'aki' | 'etsi_tl' | 'openid_federation';
            value?: string;
            verificationMethod?: {
                [key: string]: unknown;
            } | string;
        }>;
    };
    /**
     * Optional credential config to update pinning for after successful version publish.
     */
    credentialConfigId?: string;
    /**
     * How to update credential config pinning after version publish. keep_current: do not change existing pin (unless empty). update_to_new_version: update pinned version under current id. replace_id: repoint pin to config.id.
     */
    pinMode?: 'keep_current' | 'update_to_new_version' | 'replace_id';
};
type VocabularyEntryDto = {
    /**
     * Stable machine-readable value to submit in schema metadata category/tags fields.
     */
    code: string;
    /**
     * Display label for UI rendering.
     */
    label: string;
    /**
     * Vocabulary lifecycle status.
     */
    status: 'active' | 'deprecated';
    /**
     * Replacement code when status is deprecated.
     */
    replacedBy?: string;
};
type SchemaMetadataVocabulariesDto = {
    /**
     * Vocabulary publication version for cache invalidation.
     */
    version: string;
    /**
     * Allowed category values that can be used when updating schema metadata category.
     */
    categories: Array<VocabularyEntryDto>;
    /**
     * Allowed tag values that can be used when updating schema metadata tags.
     */
    tags: Array<VocabularyEntryDto>;
};
type UpdateIssuerOfferDto = {
    /**
     * URL where the user can receive a credential offer from this issuer.
     */
    credentialOfferUrl?: string;
    /**
     * Human-readable description to help users choose the right issuer.
     */
    description?: string;
};
type UpdateSchemaMetadataDto = {
    /**
     * Domain category for filtering
     */
    category?: 'identity' | 'health' | 'finance' | 'education' | 'mobility' | 'employment' | 'other';
    /**
     * Predefined tags for filtering and search
     */
    tags?: Array<'pid' | 'eudi' | 'kyc' | 'aml' | 'age-verification' | 'residency' | 'membership' | 'education' | 'employment' | 'mobility'>;
    /**
     * Optional human-readable schema name for UI display and search
     */
    displayName?: string;
    /**
     * Issuer offer entries shown to users, each with credential-offer URL and description
     */
    issuerOffers?: Array<{
        credentialOfferUrl?: string;
        description?: string;
    }>;
};
type DeprecateSchemaMetadataDto = {
    /**
     * Whether to mark this version as deprecated
     */
    deprecated: boolean;
    /**
     * Deprecation message shown to consumers
     */
    message?: string;
    /**
     * The version that supersedes this one
     */
    supersededByVersion?: string;
};
type CreateWebhookEndpointDto = {
    /**
     * Unique webhook endpoint identifier.
     */
    id: string;
    /**
     * Display name of the webhook endpoint.
     */
    name: string;
    /**
     * Optional webhook endpoint description.
     */
    description?: string | null;
    /**
     * Destination URL for webhook delivery.
     */
    url: string;
    /**
     * Authentication configuration applied to outgoing webhook requests.
     */
    auth: {
        /**
         * Disable webhook authentication.
         */
        type: 'none';
    } | {
        /**
         * Use API key authentication for webhook requests.
         */
        type: 'apiKey';
        /**
         * API key webhook authentication settings.
         */
        config: {
            /**
             * HTTP header name for the API key.
             */
            headerName: string;
            /**
             * API key value sent with webhook requests.
             */
            value: string;
        };
    };
};
type UpdateWebhookEndpointDto = {
    /**
     * Unique webhook endpoint identifier.
     */
    id?: string;
    /**
     * Display name of the webhook endpoint.
     */
    name?: string;
    /**
     * Optional webhook endpoint description.
     */
    description?: string | null;
    /**
     * Destination URL for webhook delivery.
     */
    url?: string;
    /**
     * Authentication configuration applied to outgoing webhook requests.
     */
    auth?: {
        /**
         * Disable webhook authentication.
         */
        type: 'none';
    } | {
        /**
         * Use API key authentication for webhook requests.
         */
        type: 'apiKey';
        /**
         * API key webhook authentication settings.
         */
        config: {
            /**
             * HTTP header name for the API key.
             */
            headerName: string;
            /**
             * API key value sent with webhook requests.
             */
            value: string;
        };
    };
};
type DeferredCredentialRequestDto = {
    /**
     * The transaction identifier previously returned by the Credential Endpoint
     */
    transaction_id: string;
};
type NotificationRequestDto = {
    notification_id: string;
    event: 'credential_accepted' | 'credential_failure' | 'credential_deleted';
};
type OfferResponse = {
    uri: string;
    /**
     * URI for cross-device flows (no redirect after completion)
     */
    crossDeviceUri?: string;
    session: string;
};
type CompleteDeferredDto = {
    /**
     * Claims to include in the credential. The structure should match the credential configuration's expected claims.
     */
    claims: {
        [key: string]: unknown;
    };
};
type DeferredOperationResponse = {
    /**
     * The transaction ID
     */
    transactionId: string;
    /**
     * The new status of the transaction
     */
    status: 'pending' | 'ready' | 'retrieved' | 'expired' | 'failed';
    /**
     * Optional message
     */
    message?: string;
};
type FailDeferredDto = {
    /**
     * Optional error message explaining why the issuance failed
     */
    error?: string;
};
type EcPublic = {
    /**
     * The key type, which is always 'EC' for Elliptic Curve keys.
     */
    kty: string;
    /**
     * The algorithm intended for use with the key, such as 'ES256'.
     */
    crv: string;
    /**
     * The x coordinate of the EC public key.
     */
    x: string;
    /**
     * The y coordinate of the EC public key.
     */
    y: string;
};
type JwksResponseDto = {
    /**
     * An array of EC public keys in JWK format.
     */
    keys: Array<EcPublic>;
};
type AuthorizationResponse = {
    /**
     * The response string containing the authorization details (JWE-encrypted VP token).
     * Required for success responses, absent for error responses.
     */
    response?: string;
    /**
     * When set to true, the authorization response will be sent to the client.
     */
    sendResponse?: boolean;
    error?: string;
    /**
     * Human-readable description of the error.
     */
    error_description?: string;
    /**
     * URI with additional information about the error.
     */
    error_uri?: string;
    /**
     * State value from the authorization request (for correlation).
     */
    state?: string;
};
type Object$1 = {
    [key: string]: unknown;
};
type ParResponseDto = {
    /**
     * The request URI for the Pushed Authorization Request.
     */
    request_uri: string;
    /**
     * The expiration time for the request URI in seconds.
     */
    expires_in: number;
};
type InteractiveAuthorizationRequestDto = {
    /**
     * Response type (for initial request)
     */
    response_type?: string;
    /**
     * Client identifier (for initial request)
     */
    client_id?: string;
    /**
     * Comma-separated list of supported interaction types (for initial request)
     */
    interaction_types_supported?: string;
    /**
     * Redirect URI (for initial request)
     */
    redirect_uri?: string;
    /**
     * OAuth scope
     */
    scope?: string;
    /**
     * PKCE code challenge
     */
    code_challenge?: string;
    /**
     * PKCE code challenge method
     */
    code_challenge_method?: string;
    /**
     * Authorization details
     */
    authorization_details?: Array<{
        type: string;
        format?: string;
        vct?: string;
        credential_configuration_id?: string;
    }> | string;
    /**
     * State parameter
     */
    state?: string;
    /**
     * Issuer state from credential offer
     */
    issuer_state?: string;
    /**
     * Auth session identifier (for follow-up request)
     */
    auth_session?: string;
    /**
     * OpenID4VP response (for follow-up request)
     */
    openid4vp_response?: string;
    /**
     * PKCE code verifier (for follow-up request)
     */
    code_verifier?: string;
    /**
     * JAR request JWT (by value)
     */
    request?: string;
    /**
     * JAR request URI (by reference)
     */
    request_uri?: string;
};
type InteractiveAuthorizationCodeResponseDto = {
    /**
     * Response status
     */
    status: string;
    /**
     * Authorization code
     */
    code: string;
};
type InteractiveAuthorizationErrorResponseDto = {
    /**
     * OAuth error code
     */
    error: string;
    /**
     * Human-readable error description
     */
    error_description?: string;
};
type ChainedAsParResponseDto = {
    /**
     * The request URI to use at the authorization endpoint
     */
    request_uri: string;
    /**
     * The lifetime of the request URI in seconds
     */
    expires_in: number;
};
type ChainedAsErrorResponseDto = {
    /**
     * Error code
     */
    error: string;
    /**
     * Human-readable error description
     */
    error_description?: string;
};
type ChainedAsTokenRequestDto = {
    /**
     * Grant type ('authorization_code' or 'refresh_token')
     */
    grant_type: string;
    /**
     * Authorization code received in the callback (authorization_code grant)
     */
    code?: string;
    /**
     * Refresh token (refresh_token grant)
     */
    refresh_token?: string;
    /**
     * Client identifier
     */
    client_id?: string;
    /**
     * Redirect URI (must match the one used in PAR)
     */
    redirect_uri?: string;
    /**
     * PKCE code verifier
     */
    code_verifier?: string;
};
type ChainedAsTokenResponseDto = {
    /**
     * The access token
     */
    access_token: string;
    /**
     * Token type (Bearer or DPoP)
     */
    token_type: string;
    /**
     * Token lifetime in seconds
     */
    expires_in: number;
    /**
     * Scope granted
     */
    scope?: string;
    /**
     * Authorized credential configurations
     */
    authorization_details?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * C_NONCE for credential request
     */
    c_nonce?: string;
    /**
     * C_NONCE lifetime in seconds
     */
    c_nonce_expires_in?: number;
    /**
     * Refresh token (issued when refresh tokens are enabled)
     */
    refresh_token?: string;
};
type ChainedAsParRequestDto = {
    /**
     * OAuth response type (must be 'code')
     */
    response_type: string;
    /**
     * Client identifier (wallet identifier)
     */
    client_id: string;
    /**
     * URI to redirect the wallet after authorization
     */
    redirect_uri: string;
    /**
     * PKCE code challenge
     */
    code_challenge?: string;
    /**
     * PKCE code challenge method (e.g., S256)
     */
    code_challenge_method?: string;
    /**
     * State parameter (returned in redirect)
     */
    state?: string;
    /**
     * Scope requested
     */
    scope?: string;
    /**
     * Issuer state from credential offer
     */
    issuer_state?: string;
    /**
     * Authorization details
     */
    authorization_details?: Array<string | Array<{
        [key: string]: unknown;
    }>>;
};
type PresentationRequest = {
    /**
     * Webhook configuration to receive the response.
     * If not provided, the configured webhook from the configuration will be used.
     */
    webhook?: WebhookConfig & {
        url?: string;
        auth?: {
            type: 'none';
        } | {
            type: 'apiKey';
            config: {
                headerName: string;
                value: string;
            };
        };
        includeRawTokensFor?: Array<string>;
    };
    /**
     * Optional transaction data to include in the OID4VP request.
     * If provided, this will override the transaction_data from the presentation configuration.
     */
    transaction_data?: Array<{
        /**
         * Transaction data type identifier.
         */
        type: string;
        /**
         * Credential query ids this transaction data applies to.
         */
        credential_ids: Array<string>;
        /**
         * Transaction details. Required for TS12 SCA transaction data.
         */
        payload?: unknown;
        [key: string]: unknown;
    }>;
    /**
     * The type of response expected from the presentation request.
     */
    response_type: 'uri' | 'iso-18013-7' | 'dc-api';
    /**
     * Identifier of the presentation configuration
     */
    requestId: string;
    /**
     * Optional redirect URI to which the user-agent should be redirected after the presentation is completed.
     * You can use the `{sessionId}` placeholder in the URI, which will be replaced with the actual session ID.
     */
    redirectUri?: string;
    /**
     * Optional expected browser origin for DC API key-binding audience.
     * Example: "http://localhost:8080"
     */
    expected_origin?: string;
    /**
     * Optional clock skew tolerance for this presentation offer, in seconds.
     * If provided, this overrides the presentation configuration for the created session.
     */
    skewSeconds?: number;
};
type FileUploadDto = {
    file: Blob | File;
};
type StoredObjectResponseDto = {
    /**
     * Canonical storage key
     */
    key: string;
    /**
     * ETag for the stored object
     */
    etag?: string;
    /**
     * Stored size in bytes
     */
    size?: number;
    /**
     * Public or presigned URL
     */
    url?: string;
    /**
     * MIME type of the stored object
     */
    contentType?: string;
    /**
     * Object metadata
     */
    metadata?: {
        [key: string]: string;
    };
};
type ConfigResourceMetadataEntity = {
    tenantId: string;
    kind: 'Tenant' | 'Client' | 'KmsConfig' | 'KeyChain' | 'RegistrarConfig' | 'IssuanceConfig' | 'CredentialConfig' | 'PresentationConfig' | 'AttributeProvider' | 'WebhookEndpoint' | 'TrustList' | 'StatusList';
    resourceId: string;
    ownership: 'unmanaged' | 'file-managed';
    generation: number;
    source?: string;
    sourceHash?: string;
    lastAppliedAt?: string;
    createdAt: string;
    updatedAt: string;
};
type PresentationConfigWritable = {
    /**
     * Clock skew tolerance for credential JWT time validation, in seconds.
     */
    skewSeconds?: number;
    /**
     * Status list verification mode for presentations: strict (default), best_effort, or disabled.
     */
    statusCheckMode?: 'strict' | 'best_effort' | 'disabled';
    /**
     * Unique identifier for the VP request.
     */
    id: string;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    /**
     * Description of the presentation configuration.
     */
    description?: string | null;
    /**
     * Lifetime how long the presentation request is valid after creation, in seconds.
     */
    lifeTime?: number;
    /**
     * The DCQL query to be used for the VP request.
     */
    dcql_query: Dcql;
    transaction_data?: Array<TransactionData>;
    /**
     * The registration certificate request containing the necessary details.
     */
    registration_cert?: RegistrationCertificateRequest | null;
    /**
     * Reference to the webhook endpoint used for notifications.
     * Optional: if set, notifications will be sent to this endpoint.
     */
    webhookEndpointId?: string | null;
    /**
     * The timestamp when the VP request was created.
     */
    createdAt: string;
    /**
     * The timestamp when the VP request was last updated.
     */
    updatedAt: string;
    /**
     * Attestation that should be attached
     */
    attached?: Array<PresentationAttachment> | null;
    /**
     * Redirect URI to which the user-agent should be redirected after the presentation is completed.
     * You can use the `{sessionId}` placeholder in the URI, which will be replaced with the actual session ID.
     */
    redirectUri?: string | null;
    /**
     * Optional ID of the access certificate to use for signing the presentation request.
     * If not provided, the default access certificate for the tenant will be used.
     *
     * Note: This is intentionally NOT a TypeORM relationship because CertEntity uses
     * a composite primary key (id + tenantId), and SQLite cannot create foreign keys
     * that reference only part of a composite primary key. The relationship is handled
     * at the application level in the service layer.
     */
    accessKeyChainId?: string | null;
    /**
     * Enable reader authentication for the ISO 18013-7 Annex C (DC API) flow.
     *
     * When `true`, the DeviceRequest embeds a detached `readerAuth` COSE_Sign1
     * signed with the tenant's Access key chain (selected by
     * {@link accessKeyChainId}), letting the wallet cryptographically
     * authenticate the verifier — the mDOC equivalent of the signed request
     * object used in the OID4VP flow. Defaults to disabled (null/false).
     *
     * Only affects `response_type: "iso-18013-7"` offers.
     */
    readerAuth?: boolean | null;
};
type IssuanceConfigWritable = {
    /**
     * Shared wallet provider trust lists for key attestations at the credential endpoint
     * and default wallet-attestation trust at managed authorization servers.
     * Each entry MUST include either `verifierKey` or `verifierX509Der`.
     */
    walletProviderTrustLists?: Array<WalletProviderTrustListRefDto>;
    /**
     * Key ID for signing access tokens. If unset, the default signing key is used.
     */
    signingKeyId?: string;
    /**
     * Dedicated managed authorization servers hosted by this issuer. At least one entry is required.
     */
    authorizationServers: Array<ExternalAuthorizationServerConfig | Oid4VpAuthorizationServerConfig | ChainedAuthorizationServerConfig | BuiltInAuthorizationServerConfig>;
    /**
     * Optional OpenID Federation configuration used for trust evaluation.
     * When omitted, trust checks rely on existing LoTE trust-list behavior.
     */
    federation?: FederationConfig | null;
    /**
     * Optional registration certificate configuration for issuer metadata (`issuer_info`).
     * Supports importing an existing JWT or generating one via registrar.
     */
    registrationCertificate?: IssuerRegistrationCertificateConfig | null;
    /**
     * Whether the OID4VCI notification endpoint is exposed for this issuance configuration.
     */
    notificationEndpointEnabled?: boolean;
    /**
     * Whether `credential_response_encryption` should be advertised in the credential issuer metadata.
     */
    credentialResponseEncryption?: boolean;
    /**
     * Whether `credential_request_encryption` should be advertised in the credential issuer metadata.
     */
    credentialRequestEncryption?: boolean;
    /**
     * Maximum failed tx_code attempts before the pre-authorized code is invalidated. Defaults to 5.
     */
    txCodeMaxAttempts?: number | null;
    /**
     * The tenant that owns this object.
     */
    tenant: TenantEntity;
    /**
     * Value to determine the amount of credentials that are issued in a batch.
     * Default is 1.
     */
    batchSize?: number;
    /**
     * Indicates whether DPoP is required for the issuance process. Default value is true.
     */
    dPopRequired?: boolean;
    /**
     * Default wallet attestation requirement for managed authorization servers.
     * When enabled, wallets must provide OAuth-Client-Attestation headers.
     * Default value is false.
     */
    walletAttestationRequired?: boolean;
    display: Array<DisplayInfo>;
    /**
     * The timestamp when the VP request was created.
     */
    createdAt: string;
    /**
     * The timestamp when the VP request was last updated.
     */
    updatedAt: string;
};
type UpdateIssuanceDtoWritable = {
    /**
     * Shared wallet provider trust lists for key attestations at the credential endpoint
     * and default wallet-attestation trust at managed authorization servers.
     * Each entry MUST include either `verifierKey` or `verifierX509Der`.
     */
    walletProviderTrustLists?: Array<WalletProviderTrustListRefDto>;
    /**
     * Key ID for signing access tokens. If unset, the default signing key is used.
     */
    signingKeyId?: string;
    /**
     * Dedicated managed authorization servers hosted by this issuer. At least one entry is required.
     */
    authorizationServers?: Array<ExternalAuthorizationServerConfig | Oid4VpAuthorizationServerConfig | ChainedAuthorizationServerConfig | BuiltInAuthorizationServerConfig>;
    /**
     * Optional OpenID Federation configuration used for trust evaluation.
     * When omitted, trust checks rely on existing LoTE trust-list behavior.
     */
    federation?: FederationConfig | null;
    /**
     * Optional registration certificate configuration for issuer metadata (`issuer_info`).
     * Supports importing an existing JWT or generating one via registrar.
     */
    registrationCertificate?: IssuerRegistrationCertificateConfig | null;
    /**
     * Whether the OID4VCI notification endpoint is exposed for this issuance configuration.
     */
    notificationEndpointEnabled?: boolean;
    /**
     * Whether `credential_response_encryption` should be advertised in the credential issuer metadata.
     */
    credentialResponseEncryption?: boolean;
    /**
     * Whether `credential_request_encryption` should be advertised in the credential issuer metadata.
     */
    credentialRequestEncryption?: boolean;
    /**
     * Maximum failed tx_code attempts before the pre-authorized code is invalidated. Defaults to 5.
     */
    txCodeMaxAttempts?: number | null;
    /**
     * Value to determine the amount of credentials that are issued in a batch.
     * Default is 1.
     */
    batchSize?: number;
    /**
     * Indicates whether DPoP is required for the issuance process. Default value is true.
     */
    dPopRequired?: boolean;
    /**
     * Default wallet attestation requirement for managed authorization servers.
     * When enabled, wallets must provide OAuth-Client-Attestation headers.
     * Default value is false.
     */
    walletAttestationRequired?: boolean;
    display?: Array<DisplayInfo>;
};
type ObjectWritable = {
    [key: string]: unknown;
};
type AppControllerGetVersionData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/version';
};
type AppControllerGetVersionResponses = {
    /**
     * Service version info
     */
    200: VersionResponseDto;
};
type AppControllerGetVersionResponse = AppControllerGetVersionResponses[keyof AppControllerGetVersionResponses];
type AppControllerGetFrontendConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/frontend-config';
};
type AppControllerGetFrontendConfigResponses = {
    /**
     * Frontend configuration
     */
    200: FrontendConfigResponseDto;
};
type AppControllerGetFrontendConfigResponse = AppControllerGetFrontendConfigResponses[keyof AppControllerGetFrontendConfigResponses];
type AuthControllerGetOAuth2TokenData = {
    body: ClientCredentialsDto;
    path?: never;
    query?: never;
    url: '/api/oauth2/token';
};
type AuthControllerGetOAuth2TokenErrors = {
    /**
     * Invalid client credentials
     */
    401: OAuthTokenErrorResponseDto;
};
type AuthControllerGetOAuth2TokenError = AuthControllerGetOAuth2TokenErrors[keyof AuthControllerGetOAuth2TokenErrors];
type AuthControllerGetOAuth2TokenResponses = {
    /**
     * OAuth2 token response
     */
    200: TokenResponse;
};
type AuthControllerGetOAuth2TokenResponse = AuthControllerGetOAuth2TokenResponses[keyof AuthControllerGetOAuth2TokenResponses];
type TenantControllerGetTenantsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/tenant';
};
type TenantControllerGetTenantsResponses = {
    200: Array<TenantResponseDto>;
};
type TenantControllerGetTenantsResponse = TenantControllerGetTenantsResponses[keyof TenantControllerGetTenantsResponses];
type TenantControllerInitTenantData = {
    body: CreateTenantDto;
    path?: never;
    query?: never;
    url: '/api/tenant';
};
type TenantControllerInitTenantResponses = {
    201: TenantCreateResponseDto;
};
type TenantControllerInitTenantResponse = TenantControllerInitTenantResponses[keyof TenantControllerInitTenantResponses];
type TenantControllerDeleteTenantData = {
    body?: never;
    path: {
        /**
         * The ID of the tenant to delete
         */
        id: string;
    };
    query?: never;
    url: '/api/tenant/{id}';
};
type TenantControllerDeleteTenantResponses = {
    /**
     * Tenant deleted
     */
    204: void;
};
type TenantControllerDeleteTenantResponse = TenantControllerDeleteTenantResponses[keyof TenantControllerDeleteTenantResponses];
type TenantControllerGetTenantData = {
    body?: never;
    path: {
        /**
         * The ID of the tenant
         */
        id: string;
    };
    query?: never;
    url: '/api/tenant/{id}';
};
type TenantControllerGetTenantResponses = {
    200: TenantResponseDto;
};
type TenantControllerGetTenantResponse = TenantControllerGetTenantResponses[keyof TenantControllerGetTenantResponses];
type TenantControllerUpdateTenantData = {
    body: UpdateTenantDto;
    path: {
        /**
         * The ID of the tenant
         */
        id: string;
    };
    query?: never;
    url: '/api/tenant/{id}';
};
type TenantControllerUpdateTenantResponses = {
    200: TenantResponseDto;
};
type TenantControllerUpdateTenantResponse = TenantControllerUpdateTenantResponses[keyof TenantControllerUpdateTenantResponses];
type AuditLogControllerGetAuditLogsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Maximum number of entries to return (1–500)
         */
        limit?: number;
    };
    url: '/api/admin/audit-logs';
};
type AuditLogControllerGetAuditLogsResponses = {
    200: Array<AuditLogResponseDto>;
};
type AuditLogControllerGetAuditLogsResponse = AuditLogControllerGetAuditLogsResponses[keyof AuditLogControllerGetAuditLogsResponses];
type ClientControllerGetClientsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/client';
};
type ClientControllerGetClientsResponses = {
    200: Array<ClientEntity>;
};
type ClientControllerGetClientsResponse = ClientControllerGetClientsResponses[keyof ClientControllerGetClientsResponses];
type ClientControllerCreateClientData = {
    body: CreateClientDto;
    path?: never;
    query?: never;
    url: '/api/client';
};
type ClientControllerCreateClientResponses = {
    201: ClientEntity;
};
type ClientControllerCreateClientResponse = ClientControllerCreateClientResponses[keyof ClientControllerCreateClientResponses];
type ClientControllerDeleteClientData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/client/{id}';
};
type ClientControllerDeleteClientResponses = {
    /**
     * Client deleted
     */
    204: void;
};
type ClientControllerDeleteClientResponse = ClientControllerDeleteClientResponses[keyof ClientControllerDeleteClientResponses];
type ClientControllerGetClientData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/client/{id}';
};
type ClientControllerGetClientErrors = {
    /**
     * Client not found
     */
    404: unknown;
};
type ClientControllerGetClientResponses = {
    200: ClientEntity;
};
type ClientControllerGetClientResponse = ClientControllerGetClientResponses[keyof ClientControllerGetClientResponses];
type ClientControllerUpdateClientData = {
    body: UpdateClientDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/client/{id}';
};
type ClientControllerUpdateClientErrors = {
    /**
     * Client not found
     */
    404: unknown;
};
type ClientControllerUpdateClientResponses = {
    200: ClientEntity;
};
type ClientControllerUpdateClientResponse = ClientControllerUpdateClientResponses[keyof ClientControllerUpdateClientResponses];
type ClientControllerRotateClientSecretData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/client/{id}/rotate-secret';
};
type ClientControllerRotateClientSecretResponses = {
    201: ClientSecretResponseDto;
};
type ClientControllerRotateClientSecretResponse = ClientControllerRotateClientSecretResponses[keyof ClientControllerRotateClientSecretResponses];
type RegistrarControllerDeleteConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/registrar/config';
};
type RegistrarControllerDeleteConfigResponses = {
    /**
     * Configuration deleted successfully
     */
    204: void;
};
type RegistrarControllerDeleteConfigResponse = RegistrarControllerDeleteConfigResponses[keyof RegistrarControllerDeleteConfigResponses];
type RegistrarControllerGetConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/registrar/config';
};
type RegistrarControllerGetConfigErrors = {
    /**
     * No registrar configuration found
     */
    404: unknown;
};
type RegistrarControllerGetConfigResponses = {
    /**
     * The registrar configuration
     */
    200: RegistrarConfigResponseDto;
};
type RegistrarControllerGetConfigResponse = RegistrarControllerGetConfigResponses[keyof RegistrarControllerGetConfigResponses];
type RegistrarControllerUpdateConfigData = {
    body: UpdateRegistrarConfigDto;
    path?: never;
    query?: never;
    url: '/api/registrar/config';
};
type RegistrarControllerUpdateConfigErrors = {
    /**
     * Invalid credentials
     */
    400: unknown;
    /**
     * No registrar configuration found
     */
    404: unknown;
    /**
     * Registrar OIDC endpoint unreachable — credentials could not be verified
     */
    503: unknown;
};
type RegistrarControllerUpdateConfigResponses = {
    /**
     * Configuration updated successfully
     */
    200: RegistrarConfigResponseDto;
};
type RegistrarControllerUpdateConfigResponse = RegistrarControllerUpdateConfigResponses[keyof RegistrarControllerUpdateConfigResponses];
type RegistrarControllerCreateConfigData = {
    body: CreateRegistrarConfigDto;
    path?: never;
    query?: never;
    url: '/api/registrar/config';
};
type RegistrarControllerCreateConfigErrors = {
    /**
     * Invalid credentials
     */
    400: unknown;
    /**
     * Registrar OIDC endpoint unreachable — credentials could not be verified
     */
    503: unknown;
};
type RegistrarControllerCreateConfigResponses = {
    /**
     * Configuration created successfully
     */
    201: RegistrarConfigResponseDto;
};
type RegistrarControllerCreateConfigResponse = RegistrarControllerCreateConfigResponses[keyof RegistrarControllerCreateConfigResponses];
type RegistrarControllerCreateAccessCertificateData = {
    body: CreateAccessCertificateDto;
    path?: never;
    query?: never;
    url: '/api/registrar/access-certificate';
};
type RegistrarControllerCreateAccessCertificateErrors = {
    /**
     * No relying party found at registrar or failed to create certificate
     */
    400: unknown;
    /**
     * No registrar configuration found or key not found
     */
    404: unknown;
};
type RegistrarControllerCreateAccessCertificateResponses = {
    /**
     * Access certificate created successfully
     */
    201: {
        /**
         * The certificate ID at the registrar
         */
        id?: string;
        /**
         * The certificate in PEM format
         */
        crt?: string;
    };
};
type RegistrarControllerCreateAccessCertificateResponse = RegistrarControllerCreateAccessCertificateResponses[keyof RegistrarControllerCreateAccessCertificateResponses];
type UserControllerGetUsersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/user';
};
type UserControllerGetUsersResponses = {
    200: Array<ManagedUserDto>;
};
type UserControllerGetUsersResponse = UserControllerGetUsersResponses[keyof UserControllerGetUsersResponses];
type UserControllerCreateUserData = {
    body: CreateUserDto;
    path?: never;
    query?: never;
    url: '/api/user';
};
type UserControllerCreateUserResponses = {
    201: ManagedUserDto;
};
type UserControllerCreateUserResponse = UserControllerCreateUserResponses[keyof UserControllerCreateUserResponses];
type UserControllerDeleteUserData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/user/{id}';
};
type UserControllerDeleteUserResponses = {
    /**
     * User deleted
     */
    204: void;
};
type UserControllerDeleteUserResponse = UserControllerDeleteUserResponses[keyof UserControllerDeleteUserResponses];
type UserControllerGetUserData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/user/{id}';
};
type UserControllerGetUserResponses = {
    200: ManagedUserDto;
};
type UserControllerGetUserResponse = UserControllerGetUserResponses[keyof UserControllerGetUserResponses];
type UserControllerUpdateUserData = {
    body: UpdateUserDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/user/{id}';
};
type UserControllerUpdateUserResponses = {
    200: ManagedUserDto;
};
type UserControllerUpdateUserResponse = UserControllerUpdateUserResponses[keyof UserControllerUpdateUserResponses];
type KeyChainControllerGetProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/key-chain/providers';
};
type KeyChainControllerGetProvidersResponses = {
    /**
     * List of available KMS providers with capabilities
     */
    200: KmsProvidersResponseDto;
};
type KeyChainControllerGetProvidersResponse = KeyChainControllerGetProvidersResponses[keyof KeyChainControllerGetProvidersResponses];
type KeyChainControllerGetProvidersHealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/key-chain/providers/health';
};
type KeyChainControllerGetProvidersHealthResponses = {
    /**
     * Per-provider health result (ok, latencyMs, optional error).
     */
    200: Array<ProviderHealthResponseDto>;
};
type KeyChainControllerGetProvidersHealthResponse = KeyChainControllerGetProvidersHealthResponses[keyof KeyChainControllerGetProvidersHealthResponses];
type KeyChainControllerDeleteTenantKmsConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/key-chain/providers/config';
};
type KeyChainControllerDeleteTenantKmsConfigResponses = {
    /**
     * Tenant-specific KMS config removed.
     */
    204: void;
};
type KeyChainControllerDeleteTenantKmsConfigResponse = KeyChainControllerDeleteTenantKmsConfigResponses[keyof KeyChainControllerDeleteTenantKmsConfigResponses];
type KeyChainControllerGetTenantKmsConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/key-chain/providers/config';
};
type KeyChainControllerGetTenantKmsConfigResponses = {
    /**
     * Tenant and effective KMS configuration.
     */
    200: KmsTenantConfigResponseDto;
};
type KeyChainControllerGetTenantKmsConfigResponse = KeyChainControllerGetTenantKmsConfigResponses[keyof KeyChainControllerGetTenantKmsConfigResponses];
type KeyChainControllerUpdateTenantKmsConfigData = {
    body: KmsConfigDto;
    path?: never;
    query?: never;
    url: '/api/key-chain/providers/config';
};
type KeyChainControllerUpdateTenantKmsConfigResponses = {
    /**
     * Updated tenant KMS config.
     */
    200: KmsTenantConfigResponseDto;
};
type KeyChainControllerUpdateTenantKmsConfigResponse = KeyChainControllerUpdateTenantKmsConfigResponses[keyof KeyChainControllerUpdateTenantKmsConfigResponses];
type KeyChainControllerGetAllData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Optional usage type filter
         */
        usageType?: 'access' | 'attestation' | 'trustList' | 'statusList' | 'encrypt';
    };
    url: '/api/key-chain';
};
type KeyChainControllerGetAllResponses = {
    /**
     * List of key chains
     */
    200: Array<KeyChainResponseDto>;
};
type KeyChainControllerGetAllResponse = KeyChainControllerGetAllResponses[keyof KeyChainControllerGetAllResponses];
type KeyChainControllerCreateData = {
    body: KeyChainCreateDto;
    path?: never;
    query?: never;
    url: '/api/key-chain';
};
type KeyChainControllerCreateResponses = {
    /**
     * Key chain created successfully
     */
    201: KeyChainIdResponseDto;
};
type KeyChainControllerCreateResponse = KeyChainControllerCreateResponses[keyof KeyChainControllerCreateResponses];
type KeyChainControllerDeleteData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/key-chain/{id}';
};
type KeyChainControllerDeleteErrors = {
    /**
     * Key chain not found
     */
    404: unknown;
};
type KeyChainControllerDeleteResponses = {
    /**
     * Key chain deleted successfully
     */
    204: void;
};
type KeyChainControllerDeleteResponse = KeyChainControllerDeleteResponses[keyof KeyChainControllerDeleteResponses];
type KeyChainControllerGetByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/key-chain/{id}';
};
type KeyChainControllerGetByIdErrors = {
    /**
     * Key chain not found
     */
    404: unknown;
};
type KeyChainControllerGetByIdResponses = {
    /**
     * The key chain
     */
    200: KeyChainResponseDto;
};
type KeyChainControllerGetByIdResponse = KeyChainControllerGetByIdResponses[keyof KeyChainControllerGetByIdResponses];
type KeyChainControllerUpdateData = {
    body: KeyChainUpdateDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/key-chain/{id}';
};
type KeyChainControllerUpdateErrors = {
    /**
     * Key chain not found
     */
    404: unknown;
};
type KeyChainControllerUpdateResponses = {
    /**
     * Key chain updated successfully
     */
    204: void;
};
type KeyChainControllerUpdateResponse = KeyChainControllerUpdateResponses[keyof KeyChainControllerUpdateResponses];
type KeyChainControllerExportData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/key-chain/{id}/export';
};
type KeyChainControllerExportErrors = {
    /**
     * Key chain not found
     */
    404: unknown;
};
type KeyChainControllerExportResponses = {
    /**
     * Key chain export data
     */
    200: KeyChainExportDto;
};
type KeyChainControllerExportResponse = KeyChainControllerExportResponses[keyof KeyChainControllerExportResponses];
type KeyChainControllerImportData = {
    body: KeyChainImportDto;
    path?: never;
    query?: never;
    url: '/api/key-chain/import';
};
type KeyChainControllerImportResponses = {
    /**
     * Key chain imported successfully
     */
    201: KeyChainIdResponseDto;
};
type KeyChainControllerImportResponse = KeyChainControllerImportResponses[keyof KeyChainControllerImportResponses];
type KeyChainControllerRotateData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/key-chain/{id}/rotate';
};
type KeyChainControllerRotateErrors = {
    /**
     * Key chain not found
     */
    404: unknown;
};
type KeyChainControllerRotateResponses = {
    /**
     * Key chain rotated successfully
     */
    204: void;
};
type KeyChainControllerRotateResponse = KeyChainControllerRotateResponses[keyof KeyChainControllerRotateResponses];
type AttributeProviderControllerGetAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/issuer/attribute-providers';
};
type AttributeProviderControllerGetAllResponses = {
    /**
     * List of attribute providers
     */
    200: Array<AttributeProviderEntity>;
};
type AttributeProviderControllerGetAllResponse = AttributeProviderControllerGetAllResponses[keyof AttributeProviderControllerGetAllResponses];
type AttributeProviderControllerCreateData = {
    body: CreateAttributeProviderDto;
    path?: never;
    query?: never;
    url: '/api/issuer/attribute-providers';
};
type AttributeProviderControllerCreateResponses = {
    /**
     * Attribute provider created
     */
    201: AttributeProviderEntity;
};
type AttributeProviderControllerCreateResponse = AttributeProviderControllerCreateResponses[keyof AttributeProviderControllerCreateResponses];
type AttributeProviderControllerDeleteData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/attribute-providers/{id}';
};
type AttributeProviderControllerDeleteErrors = {
    /**
     * Attribute provider not found
     */
    404: unknown;
};
type AttributeProviderControllerDeleteResponses = {
    /**
     * Attribute provider deleted
     */
    204: void;
};
type AttributeProviderControllerDeleteResponse = AttributeProviderControllerDeleteResponses[keyof AttributeProviderControllerDeleteResponses];
type AttributeProviderControllerGetByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/attribute-providers/{id}';
};
type AttributeProviderControllerGetByIdErrors = {
    /**
     * Attribute provider not found
     */
    404: unknown;
};
type AttributeProviderControllerGetByIdResponses = {
    /**
     * The attribute provider
     */
    200: AttributeProviderEntity;
};
type AttributeProviderControllerGetByIdResponse = AttributeProviderControllerGetByIdResponses[keyof AttributeProviderControllerGetByIdResponses];
type AttributeProviderControllerUpdateData = {
    body: UpdateAttributeProviderDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/attribute-providers/{id}';
};
type AttributeProviderControllerUpdateErrors = {
    /**
     * Attribute provider not found
     */
    404: unknown;
};
type AttributeProviderControllerUpdateResponses = {
    /**
     * Attribute provider updated
     */
    200: AttributeProviderEntity;
};
type AttributeProviderControllerUpdateResponse = AttributeProviderControllerUpdateResponses[keyof AttributeProviderControllerUpdateResponses];
type SessionControllerGetAllSessionsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Page number (1-based)
         */
        page?: number;
        /**
         * Number of items per page
         */
        pageSize?: number;
        /**
         * Filter by session status
         */
        status?: 'active' | 'fetched' | 'completed' | 'expired' | 'failed';
        /**
         * Filter by session type
         */
        type?: 'issuance' | 'presentation';
        /**
         * Field to sort by
         */
        sortBy?: 'id' | 'status' | 'createdAt' | 'requestId';
        /**
         * Sort direction
         */
        sortOrder?: 'asc' | 'desc';
    };
    url: '/api/session';
};
type SessionControllerGetAllSessionsResponses = {
    200: PaginatedSessionResponseDto;
};
type SessionControllerGetAllSessionsResponse = SessionControllerGetAllSessionsResponses[keyof SessionControllerGetAllSessionsResponses];
type SessionControllerDeleteSessionData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/session/{id}';
};
type SessionControllerDeleteSessionResponses = {
    /**
     * Session deleted
     */
    204: void;
};
type SessionControllerDeleteSessionResponse = SessionControllerDeleteSessionResponses[keyof SessionControllerDeleteSessionResponses];
type SessionControllerGetSessionData = {
    body?: never;
    path: {
        /**
         * The session ID
         */
        id: string;
    };
    query?: never;
    url: '/api/session/{id}';
};
type SessionControllerGetSessionResponses = {
    200: Session;
};
type SessionControllerGetSessionResponse = SessionControllerGetSessionResponses[keyof SessionControllerGetSessionResponses];
type SessionControllerGetSessionLogsData = {
    body?: never;
    path: {
        /**
         * The session ID
         */
        id: string;
    };
    query?: never;
    url: '/api/session/{id}/logs';
};
type SessionControllerGetSessionLogsResponses = {
    200: Array<SessionLogEntryResponseDto>;
};
type SessionControllerGetSessionLogsResponse = SessionControllerGetSessionLogsResponses[keyof SessionControllerGetSessionLogsResponses];
type SessionControllerRevokeAllData = {
    body: StatusUpdateDto;
    path?: never;
    query?: never;
    url: '/api/session/revoke';
};
type SessionControllerRevokeAllResponses = {
    /**
     * All sessions revoked
     */
    204: void;
};
type SessionControllerRevokeAllResponse = SessionControllerRevokeAllResponses[keyof SessionControllerRevokeAllResponses];
type SessionConfigControllerResetConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/session-config';
};
type SessionConfigControllerResetConfigResponses = {
    /**
     * Configuration reset successfully
     */
    204: void;
};
type SessionConfigControllerResetConfigResponse = SessionConfigControllerResetConfigResponses[keyof SessionConfigControllerResetConfigResponses];
type SessionConfigControllerGetConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/session-config';
};
type SessionConfigControllerGetConfigResponses = {
    /**
     * The session storage configuration
     */
    200: SessionStorageConfig;
};
type SessionConfigControllerGetConfigResponse = SessionConfigControllerGetConfigResponses[keyof SessionConfigControllerGetConfigResponses];
type SessionConfigControllerUpdateConfigData = {
    body: UpdateSessionConfigDto;
    path?: never;
    query?: never;
    url: '/api/session-config';
};
type SessionConfigControllerUpdateConfigResponses = {
    /**
     * The updated session storage configuration
     */
    200: SessionStorageConfig;
};
type SessionConfigControllerUpdateConfigResponse = SessionConfigControllerUpdateConfigResponses[keyof SessionConfigControllerUpdateConfigResponses];
type SessionEventsControllerSubscribeToSessionEventsData = {
    body?: never;
    path: {
        /**
         * Session ID to subscribe to
         */
        id: string;
    };
    query: {
        /**
         * JWT access token for authentication
         */
        token: string;
    };
    url: '/api/session/{id}/events';
};
type SessionEventsControllerSubscribeToSessionEventsResponses = {
    /**
     * Server-Sent Events stream of session updates
     */
    200: string;
};
type SessionEventsControllerSubscribeToSessionEventsResponse = SessionEventsControllerSubscribeToSessionEventsResponses[keyof SessionEventsControllerSubscribeToSessionEventsResponses];
type StatusListConfigControllerResetConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/status-list-config';
};
type StatusListConfigControllerResetConfigResponses = {
    /**
     * Configuration reset successfully
     */
    204: void;
};
type StatusListConfigControllerResetConfigResponse = StatusListConfigControllerResetConfigResponses[keyof StatusListConfigControllerResetConfigResponses];
type StatusListConfigControllerGetConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/status-list-config';
};
type StatusListConfigControllerGetConfigResponses = {
    /**
     * The status list configuration
     */
    200: StatusListConfig;
};
type StatusListConfigControllerGetConfigResponse = StatusListConfigControllerGetConfigResponses[keyof StatusListConfigControllerGetConfigResponses];
type StatusListConfigControllerUpdateConfigData = {
    body: UpdateStatusListConfigDto;
    path?: never;
    query?: never;
    url: '/api/status-list-config';
};
type StatusListConfigControllerUpdateConfigResponses = {
    /**
     * The updated status list configuration
     */
    200: StatusListConfig;
};
type StatusListConfigControllerUpdateConfigResponse = StatusListConfigControllerUpdateConfigResponses[keyof StatusListConfigControllerUpdateConfigResponses];
type StatusListManagementControllerGetListsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/status-lists';
};
type StatusListManagementControllerGetListsResponses = {
    /**
     * List of status lists
     */
    200: Array<StatusListResponseDto>;
};
type StatusListManagementControllerGetListsResponse = StatusListManagementControllerGetListsResponses[keyof StatusListManagementControllerGetListsResponses];
type StatusListManagementControllerCreateListData = {
    body: CreateStatusListDto;
    path?: never;
    query?: never;
    url: '/api/status-lists';
};
type StatusListManagementControllerCreateListResponses = {
    /**
     * The created status list
     */
    201: StatusListResponseDto;
};
type StatusListManagementControllerCreateListResponse = StatusListManagementControllerCreateListResponses[keyof StatusListManagementControllerCreateListResponses];
type StatusListManagementControllerDeleteListData = {
    body?: never;
    path: {
        /**
         * The status list ID
         */
        listId: string;
    };
    query?: never;
    url: '/api/status-lists/{listId}';
};
type StatusListManagementControllerDeleteListResponses = {
    /**
     * Status list deleted successfully
     */
    204: void;
};
type StatusListManagementControllerDeleteListResponse = StatusListManagementControllerDeleteListResponses[keyof StatusListManagementControllerDeleteListResponses];
type StatusListManagementControllerGetListData = {
    body?: never;
    path: {
        /**
         * The status list ID
         */
        listId: string;
    };
    query?: never;
    url: '/api/status-lists/{listId}';
};
type StatusListManagementControllerGetListResponses = {
    /**
     * The status list
     */
    200: StatusListResponseDto;
};
type StatusListManagementControllerGetListResponse = StatusListManagementControllerGetListResponses[keyof StatusListManagementControllerGetListResponses];
type StatusListManagementControllerUpdateListData = {
    body: UpdateStatusListDto;
    path: {
        /**
         * The status list ID
         */
        listId: string;
    };
    query?: never;
    url: '/api/status-lists/{listId}';
};
type StatusListManagementControllerUpdateListResponses = {
    /**
     * The updated status list
     */
    200: StatusListResponseDto;
};
type StatusListManagementControllerUpdateListResponse = StatusListManagementControllerUpdateListResponses[keyof StatusListManagementControllerUpdateListResponses];
type CredentialConfigControllerGetConfigsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/issuer/credentials';
};
type CredentialConfigControllerGetConfigsResponses = {
    200: Array<CredentialConfig>;
};
type CredentialConfigControllerGetConfigsResponse = CredentialConfigControllerGetConfigsResponses[keyof CredentialConfigControllerGetConfigsResponses];
type CredentialConfigControllerStoreCredentialConfigurationData = {
    body: CredentialConfigCreate;
    path?: never;
    query?: never;
    url: '/api/issuer/credentials';
};
type CredentialConfigControllerStoreCredentialConfigurationResponses = {
    201: CredentialConfig;
};
type CredentialConfigControllerStoreCredentialConfigurationResponse = CredentialConfigControllerStoreCredentialConfigurationResponses[keyof CredentialConfigControllerStoreCredentialConfigurationResponses];
type CredentialConfigControllerDeleteIssuanceConfigurationData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/credentials/{id}';
};
type CredentialConfigControllerDeleteIssuanceConfigurationResponses = {
    /**
     * Credential configuration deleted
     */
    204: void;
};
type CredentialConfigControllerDeleteIssuanceConfigurationResponse = CredentialConfigControllerDeleteIssuanceConfigurationResponses[keyof CredentialConfigControllerDeleteIssuanceConfigurationResponses];
type CredentialConfigControllerGetConfigByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/credentials/{id}';
};
type CredentialConfigControllerGetConfigByIdResponses = {
    200: CredentialConfig;
};
type CredentialConfigControllerGetConfigByIdResponse = CredentialConfigControllerGetConfigByIdResponses[keyof CredentialConfigControllerGetConfigByIdResponses];
type CredentialConfigControllerUpdateCredentialConfigurationData = {
    body: CredentialConfigUpdate;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/credentials/{id}';
};
type CredentialConfigControllerUpdateCredentialConfigurationResponses = {
    200: CredentialConfig;
};
type CredentialConfigControllerUpdateCredentialConfigurationResponse = CredentialConfigControllerUpdateCredentialConfigurationResponses[keyof CredentialConfigControllerUpdateCredentialConfigurationResponses];
type PresentationManagementControllerConfigurationData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/verifier/config';
};
type PresentationManagementControllerConfigurationResponses = {
    200: Array<PresentationConfig>;
};
type PresentationManagementControllerConfigurationResponse = PresentationManagementControllerConfigurationResponses[keyof PresentationManagementControllerConfigurationResponses];
type PresentationManagementControllerStorePresentationConfigData = {
    body: PresentationConfigCreateDto;
    path?: never;
    query?: never;
    url: '/api/verifier/config';
};
type PresentationManagementControllerStorePresentationConfigResponses = {
    201: PresentationConfig;
};
type PresentationManagementControllerStorePresentationConfigResponse = PresentationManagementControllerStorePresentationConfigResponses[keyof PresentationManagementControllerStorePresentationConfigResponses];
type PresentationManagementControllerResolveIssuerMetadataData = {
    body: ResolveIssuerMetadataDto;
    path?: never;
    query?: never;
    url: '/api/verifier/config/issuer-metadata/resolve';
};
type PresentationManagementControllerResolveIssuerMetadataErrors = {
    /**
     * Invalid issuer URL or metadata could not be resolved
     */
    400: unknown;
};
type PresentationManagementControllerResolveIssuerMetadataResponses = {
    /**
     * Resolved credential issuer metadata
     */
    200: CredentialIssuerMetadataDto;
};
type PresentationManagementControllerResolveIssuerMetadataResponse = PresentationManagementControllerResolveIssuerMetadataResponses[keyof PresentationManagementControllerResolveIssuerMetadataResponses];
type PresentationManagementControllerResolveSchemaMetadataData = {
    body: ResolveSchemaMetadataDto;
    path?: never;
    query?: never;
    url: '/api/verifier/config/schema-metadata/resolve';
};
type PresentationManagementControllerResolveSchemaMetadataErrors = {
    /**
     * Invalid URL, invalid response, or invalid schema metadata JWT
     */
    400: unknown;
};
type PresentationManagementControllerResolveSchemaMetadataResponses = {
    /**
     * Resolved schema metadata import payload
     */
    200: ResolvedSchemaMetadataResponseDto;
};
type PresentationManagementControllerResolveSchemaMetadataResponse = PresentationManagementControllerResolveSchemaMetadataResponses[keyof PresentationManagementControllerResolveSchemaMetadataResponses];
type PresentationManagementControllerResolveSchemaMetadataJwtData = {
    body: ResolveSchemaMetadataJwtDto;
    path?: never;
    query?: never;
    url: '/api/verifier/config/schema-metadata/resolve-jwt';
};
type PresentationManagementControllerResolveSchemaMetadataJwtErrors = {
    /**
     * Invalid JWT or invalid schema metadata
     */
    400: unknown;
};
type PresentationManagementControllerResolveSchemaMetadataJwtResponses = {
    /**
     * Resolved schema metadata import payload
     */
    200: ResolvedSchemaMetadataResponseDto;
};
type PresentationManagementControllerResolveSchemaMetadataJwtResponse = PresentationManagementControllerResolveSchemaMetadataJwtResponses[keyof PresentationManagementControllerResolveSchemaMetadataJwtResponses];
type PresentationManagementControllerListSchemaMetadataCatalogData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/verifier/config/schema-metadata/catalog';
};
type PresentationManagementControllerListSchemaMetadataCatalogResponses = {
    /**
     * Catalog entries from the registrar
     */
    200: Array<SchemaMetadataResponseDto>;
};
type PresentationManagementControllerListSchemaMetadataCatalogResponse = PresentationManagementControllerListSchemaMetadataCatalogResponses[keyof PresentationManagementControllerListSchemaMetadataCatalogResponses];
type PresentationManagementControllerDeleteConfigurationData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/verifier/config/{id}';
};
type PresentationManagementControllerDeleteConfigurationResponses = {
    /**
     * Presentation configuration deleted
     */
    204: void;
};
type PresentationManagementControllerDeleteConfigurationResponse = PresentationManagementControllerDeleteConfigurationResponses[keyof PresentationManagementControllerDeleteConfigurationResponses];
type PresentationManagementControllerGetConfigurationData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/verifier/config/{id}';
};
type PresentationManagementControllerGetConfigurationResponses = {
    200: PresentationConfig;
};
type PresentationManagementControllerGetConfigurationResponse = PresentationManagementControllerGetConfigurationResponses[keyof PresentationManagementControllerGetConfigurationResponses];
type PresentationManagementControllerUpdateConfigurationData = {
    body: PresentationConfigUpdateDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/verifier/config/{id}';
};
type PresentationManagementControllerUpdateConfigurationResponses = {
    200: PresentationConfig;
};
type PresentationManagementControllerUpdateConfigurationResponse = PresentationManagementControllerUpdateConfigurationResponses[keyof PresentationManagementControllerUpdateConfigurationResponses];
type PresentationManagementControllerReissueRegistrationCertificateData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/verifier/config/{id}/registration-cert/reissue';
};
type PresentationManagementControllerReissueRegistrationCertificateErrors = {
    /**
     * Config has no registrationCert spec or registrar is not enabled
     */
    400: unknown;
};
type PresentationManagementControllerReissueRegistrationCertificateResponses = {
    /**
     * Updated presentation configuration
     */
    200: PresentationConfig;
};
type PresentationManagementControllerReissueRegistrationCertificateResponse = PresentationManagementControllerReissueRegistrationCertificateResponses[keyof PresentationManagementControllerReissueRegistrationCertificateResponses];
type TrustListControllerGetAllTrustListsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/trust-list';
};
type TrustListControllerGetAllTrustListsResponses = {
    200: Array<TrustList>;
};
type TrustListControllerGetAllTrustListsResponse = TrustListControllerGetAllTrustListsResponses[keyof TrustListControllerGetAllTrustListsResponses];
type TrustListControllerCreateTrustListData = {
    body: TrustListCreateDto;
    path?: never;
    query?: never;
    url: '/api/trust-list';
};
type TrustListControllerCreateTrustListResponses = {
    201: TrustList;
};
type TrustListControllerCreateTrustListResponse = TrustListControllerCreateTrustListResponses[keyof TrustListControllerCreateTrustListResponses];
type TrustListControllerDeleteTrustListData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/trust-list/{id}';
};
type TrustListControllerDeleteTrustListResponses = {
    /**
     * Trust list deleted
     */
    204: void;
};
type TrustListControllerDeleteTrustListResponse = TrustListControllerDeleteTrustListResponses[keyof TrustListControllerDeleteTrustListResponses];
type TrustListControllerGetTrustListData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/trust-list/{id}';
};
type TrustListControllerGetTrustListResponses = {
    200: TrustList;
};
type TrustListControllerGetTrustListResponse = TrustListControllerGetTrustListResponses[keyof TrustListControllerGetTrustListResponses];
type TrustListControllerUpdateTrustListData = {
    body: TrustListCreateDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/trust-list/{id}';
};
type TrustListControllerUpdateTrustListResponses = {
    200: TrustList;
};
type TrustListControllerUpdateTrustListResponse = TrustListControllerUpdateTrustListResponses[keyof TrustListControllerUpdateTrustListResponses];
type TrustListControllerExportTrustListData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/trust-list/{id}/export';
};
type TrustListControllerExportTrustListResponses = {
    200: TrustListCreateDto;
};
type TrustListControllerExportTrustListResponse = TrustListControllerExportTrustListResponses[keyof TrustListControllerExportTrustListResponses];
type TrustListControllerGetTrustListVersionsData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/trust-list/{id}/versions';
};
type TrustListControllerGetTrustListVersionsResponses = {
    200: Array<TrustListVersion>;
};
type TrustListControllerGetTrustListVersionsResponse = TrustListControllerGetTrustListVersionsResponses[keyof TrustListControllerGetTrustListVersionsResponses];
type TrustListControllerGetTrustListVersionData = {
    body?: never;
    path: {
        id: string;
        versionId: string;
    };
    query?: never;
    url: '/api/trust-list/{id}/versions/{versionId}';
};
type TrustListControllerGetTrustListVersionResponses = {
    200: TrustListVersion;
};
type TrustListControllerGetTrustListVersionResponse = TrustListControllerGetTrustListVersionResponses[keyof TrustListControllerGetTrustListVersionResponses];
type CacheControllerGetStatsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/cache/stats';
};
type CacheControllerGetStatsResponses = {
    /**
     * Cache statistics
     */
    200: CacheStatsResponseDto;
};
type CacheControllerGetStatsResponse = CacheControllerGetStatsResponses[keyof CacheControllerGetStatsResponses];
type CacheControllerClearAllCachesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/cache';
};
type CacheControllerClearAllCachesResponses = {
    /**
     * All caches cleared successfully
     */
    204: void;
};
type CacheControllerClearAllCachesResponse = CacheControllerClearAllCachesResponses[keyof CacheControllerClearAllCachesResponses];
type CacheControllerClearTrustListCacheData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/cache/trust-list';
};
type CacheControllerClearTrustListCacheResponses = {
    /**
     * Trust list cache cleared successfully
     */
    204: void;
};
type CacheControllerClearTrustListCacheResponse = CacheControllerClearTrustListCacheResponses[keyof CacheControllerClearTrustListCacheResponses];
type CacheControllerClearStatusListCacheData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/cache/status-list';
};
type CacheControllerClearStatusListCacheResponses = {
    /**
     * Status list cache cleared successfully
     */
    204: void;
};
type CacheControllerClearStatusListCacheResponse = CacheControllerClearStatusListCacheResponses[keyof CacheControllerClearStatusListCacheResponses];
type IssuanceConfigControllerGetIssuanceConfigurationsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/issuer/config';
};
type IssuanceConfigControllerGetIssuanceConfigurationsResponses = {
    200: IssuanceConfig;
};
type IssuanceConfigControllerGetIssuanceConfigurationsResponse = IssuanceConfigControllerGetIssuanceConfigurationsResponses[keyof IssuanceConfigControllerGetIssuanceConfigurationsResponses];
type IssuanceConfigControllerStoreIssuanceConfigurationData = {
    body: UpdateIssuanceDtoWritable;
    path?: never;
    query?: never;
    url: '/api/issuer/config';
};
type IssuanceConfigControllerStoreIssuanceConfigurationResponses = {
    200: IssuanceConfig;
};
type IssuanceConfigControllerStoreIssuanceConfigurationResponse = IssuanceConfigControllerStoreIssuanceConfigurationResponses[keyof IssuanceConfigControllerStoreIssuanceConfigurationResponses];
type IssuanceConfigControllerReissueRegistrationCertificateData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/issuer/config/registration-cert/reissue';
};
type IssuanceConfigControllerReissueRegistrationCertificateErrors = {
    /**
     * Registration certificate is not enabled/generate mode or registrar is unavailable
     */
    400: unknown;
};
type IssuanceConfigControllerReissueRegistrationCertificateResponses = {
    /**
     * Updated issuance configuration
     */
    201: IssuanceConfig;
};
type IssuanceConfigControllerReissueRegistrationCertificateResponse = IssuanceConfigControllerReissueRegistrationCertificateResponses[keyof IssuanceConfigControllerReissueRegistrationCertificateResponses];
type SchemaMetadataControllerPublishSchemaMetadataData = {
    body: SignSchemaMetaConfigDto;
    path?: never;
    query?: never;
    url: '/api/schema-metadata/publish';
};
type SchemaMetadataControllerPublishSchemaMetadataErrors = {
    /**
     * Invalid schema metadata input or file mapping
     */
    400: unknown;
};
type SchemaMetadataControllerPublishSchemaMetadataResponses = {
    /**
     * Registrar metadata entry for the freshly submitted schema metadata.
     */
    201: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerPublishSchemaMetadataResponse = SchemaMetadataControllerPublishSchemaMetadataResponses[keyof SchemaMetadataControllerPublishSchemaMetadataResponses];
type SchemaMetadataControllerPublishSchemaMetadataVersionData = {
    body: SignVersionSchemaMetaConfigDto;
    path?: never;
    query?: never;
    url: '/api/schema-metadata/publish-version';
};
type SchemaMetadataControllerPublishSchemaMetadataVersionErrors = {
    /**
     * config.id is required; or invalid schema metadata
     */
    400: unknown;
};
type SchemaMetadataControllerPublishSchemaMetadataVersionResponses = {
    /**
     * Registrar metadata entry for the newly submitted version.
     */
    201: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerPublishSchemaMetadataVersionResponse = SchemaMetadataControllerPublishSchemaMetadataVersionResponses[keyof SchemaMetadataControllerPublishSchemaMetadataVersionResponses];
type SchemaMetadataControllerGetVocabulariesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/schema-metadata/vocabularies';
};
type SchemaMetadataControllerGetVocabulariesResponses = {
    200: SchemaMetadataVocabulariesDto;
};
type SchemaMetadataControllerGetVocabulariesResponse = SchemaMetadataControllerGetVocabulariesResponses[keyof SchemaMetadataControllerGetVocabulariesResponses];
type SchemaMetadataControllerFindAllData = {
    body?: never;
    path?: never;
    query?: {
        attestationId?: string;
        version?: string;
    };
    url: '/api/schema-metadata';
};
type SchemaMetadataControllerFindAllResponses = {
    200: Array<SchemaMetadataResponseDto>;
};
type SchemaMetadataControllerFindAllResponse = SchemaMetadataControllerFindAllResponses[keyof SchemaMetadataControllerFindAllResponses];
type SchemaMetadataControllerGetMineData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/schema-metadata/mine';
};
type SchemaMetadataControllerGetMineResponses = {
    200: Array<SchemaMetadataResponseDto>;
};
type SchemaMetadataControllerGetMineResponse = SchemaMetadataControllerGetMineResponses[keyof SchemaMetadataControllerGetMineResponses];
type SchemaMetadataControllerFindOneData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}';
};
type SchemaMetadataControllerFindOneResponses = {
    200: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerFindOneResponse = SchemaMetadataControllerFindOneResponses[keyof SchemaMetadataControllerFindOneResponses];
type SchemaMetadataControllerRemoveData = {
    body?: never;
    path: {
        id: string;
        version: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions/{version}';
};
type SchemaMetadataControllerRemoveResponses = {
    /**
     * Deleted
     */
    204: void;
};
type SchemaMetadataControllerRemoveResponse = SchemaMetadataControllerRemoveResponses[keyof SchemaMetadataControllerRemoveResponses];
type SchemaMetadataControllerUpdateData = {
    body: UpdateSchemaMetadataDto;
    path: {
        id: string;
        version: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions/{version}';
};
type SchemaMetadataControllerUpdateResponses = {
    200: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerUpdateResponse = SchemaMetadataControllerUpdateResponses[keyof SchemaMetadataControllerUpdateResponses];
type SchemaMetadataControllerGetLatestData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/latest';
};
type SchemaMetadataControllerGetLatestResponses = {
    200: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerGetLatestResponse = SchemaMetadataControllerGetLatestResponses[keyof SchemaMetadataControllerGetLatestResponses];
type SchemaMetadataControllerGetVersionsData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions';
};
type SchemaMetadataControllerGetVersionsResponses = {
    200: Array<SchemaMetadataResponseDto>;
};
type SchemaMetadataControllerGetVersionsResponse = SchemaMetadataControllerGetVersionsResponses[keyof SchemaMetadataControllerGetVersionsResponses];
type SchemaMetadataControllerGetJwtData = {
    body?: never;
    path: {
        id: string;
        version: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions/{version}/jwt';
};
type SchemaMetadataControllerGetJwtResponses = {
    /**
     * Compact-serialization JWS string
     */
    200: string;
};
type SchemaMetadataControllerGetJwtResponse = SchemaMetadataControllerGetJwtResponses[keyof SchemaMetadataControllerGetJwtResponses];
type SchemaMetadataControllerGetSchemaData = {
    body?: never;
    path: {
        id: string;
        version: string;
        format: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions/{version}/schemas/{format}';
};
type SchemaMetadataControllerGetSchemaResponses = {
    /**
     * JSON Schema document for the requested format
     */
    200: {
        [key: string]: unknown;
    };
};
type SchemaMetadataControllerGetSchemaResponse = SchemaMetadataControllerGetSchemaResponses[keyof SchemaMetadataControllerGetSchemaResponses];
type SchemaMetadataControllerDeprecateVersionData = {
    body: DeprecateSchemaMetadataDto;
    path: {
        id: string;
        version: string;
    };
    query?: never;
    url: '/api/schema-metadata/{id}/versions/{version}/deprecation';
};
type SchemaMetadataControllerDeprecateVersionResponses = {
    200: SchemaMetadataResponseDto;
};
type SchemaMetadataControllerDeprecateVersionResponse = SchemaMetadataControllerDeprecateVersionResponses[keyof SchemaMetadataControllerDeprecateVersionResponses];
type WebhookEndpointControllerGetAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/issuer/webhook-endpoints';
};
type WebhookEndpointControllerGetAllResponses = {
    /**
     * List of webhook endpoints
     */
    200: Array<WebhookEndpointEntity>;
};
type WebhookEndpointControllerGetAllResponse = WebhookEndpointControllerGetAllResponses[keyof WebhookEndpointControllerGetAllResponses];
type WebhookEndpointControllerCreateData = {
    body: CreateWebhookEndpointDto;
    path?: never;
    query?: never;
    url: '/api/issuer/webhook-endpoints';
};
type WebhookEndpointControllerCreateResponses = {
    /**
     * Webhook endpoint created
     */
    201: WebhookEndpointEntity;
};
type WebhookEndpointControllerCreateResponse = WebhookEndpointControllerCreateResponses[keyof WebhookEndpointControllerCreateResponses];
type WebhookEndpointControllerDeleteData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/webhook-endpoints/{id}';
};
type WebhookEndpointControllerDeleteErrors = {
    /**
     * Webhook endpoint not found
     */
    404: unknown;
};
type WebhookEndpointControllerDeleteResponses = {
    /**
     * Webhook endpoint deleted
     */
    204: void;
};
type WebhookEndpointControllerDeleteResponse = WebhookEndpointControllerDeleteResponses[keyof WebhookEndpointControllerDeleteResponses];
type WebhookEndpointControllerGetByIdData = {
    body?: never;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/webhook-endpoints/{id}';
};
type WebhookEndpointControllerGetByIdErrors = {
    /**
     * Webhook endpoint not found
     */
    404: unknown;
};
type WebhookEndpointControllerGetByIdResponses = {
    /**
     * The webhook endpoint
     */
    200: WebhookEndpointEntity;
};
type WebhookEndpointControllerGetByIdResponse = WebhookEndpointControllerGetByIdResponses[keyof WebhookEndpointControllerGetByIdResponses];
type WebhookEndpointControllerUpdateData = {
    body: UpdateWebhookEndpointDto;
    path: {
        id: string;
    };
    query?: never;
    url: '/api/issuer/webhook-endpoints/{id}';
};
type WebhookEndpointControllerUpdateErrors = {
    /**
     * Webhook endpoint not found
     */
    404: unknown;
};
type WebhookEndpointControllerUpdateResponses = {
    /**
     * Webhook endpoint updated
     */
    200: WebhookEndpointEntity;
};
type WebhookEndpointControllerUpdateResponse = WebhookEndpointControllerUpdateResponses[keyof WebhookEndpointControllerUpdateResponses];
type CredentialOfferControllerGetOfferData = {
    body: OfferRequestDto;
    path?: never;
    query?: never;
    url: '/api/issuer/offer';
};
type CredentialOfferControllerGetOfferResponses = {
    /**
     * JSON response
     */
    201: OfferResponse;
};
type CredentialOfferControllerGetOfferResponse = CredentialOfferControllerGetOfferResponses[keyof CredentialOfferControllerGetOfferResponses];
type DeferredControllerCompleteDeferredData = {
    body: CompleteDeferredDto;
    path: {
        /**
         * The transaction ID returned when issuance was deferred
         */
        transactionId: string;
    };
    query?: never;
    url: '/api/issuer/deferred/{transactionId}/complete';
};
type DeferredControllerCompleteDeferredErrors = {
    /**
     * Transaction not found
     */
    404: unknown;
};
type DeferredControllerCompleteDeferredResponses = {
    /**
     * Transaction completed successfully
     */
    200: DeferredOperationResponse;
};
type DeferredControllerCompleteDeferredResponse = DeferredControllerCompleteDeferredResponses[keyof DeferredControllerCompleteDeferredResponses];
type DeferredControllerFailDeferredData = {
    body: FailDeferredDto;
    path: {
        /**
         * The transaction ID returned when issuance was deferred
         */
        transactionId: string;
    };
    query?: never;
    url: '/api/issuer/deferred/{transactionId}/fail';
};
type DeferredControllerFailDeferredErrors = {
    /**
     * Transaction not found
     */
    404: unknown;
};
type DeferredControllerFailDeferredResponses = {
    /**
     * Transaction marked as failed
     */
    200: DeferredOperationResponse;
};
type DeferredControllerFailDeferredResponse = DeferredControllerFailDeferredResponses[keyof DeferredControllerFailDeferredResponses];
type ChainedAsVpControllerParData = {
    body: ChainedAsParRequestDto;
    headers?: {
        /**
         * DPoP proof JWT
         */
        DPoP?: string;
        /**
         * Wallet attestation JWT
         */
        'OAuth-Client-Attestation'?: string;
        /**
         * Wallet attestation proof-of-possession JWT
         */
        'OAuth-Client-Attestation-PoP'?: string;
    };
    path: {
        /**
         * Tenant identifier
         */
        tenantId: string;
    };
    query?: never;
    url: '/api/issuers/{tenantId}/chained-as-vp/par';
};
type ChainedAsVpControllerParErrors = {
    400: ChainedAsErrorResponseDto;
};
type ChainedAsVpControllerParError = ChainedAsVpControllerParErrors[keyof ChainedAsVpControllerParErrors];
type ChainedAsVpControllerParResponses = {
    201: ChainedAsParResponseDto;
};
type ChainedAsVpControllerParResponse = ChainedAsVpControllerParResponses[keyof ChainedAsVpControllerParResponses];
type ChainedAsVpControllerAuthorizeData = {
    body?: never;
    path: {
        /**
         * Tenant identifier
         */
        tenantId: string;
    };
    query: {
        /**
         * Client identifier
         */
        client_id: string;
        /**
         * Request URI from PAR response
         */
        request_uri: string;
        /**
         * State parameter (returned in redirect)
         */
        state?: string;
    };
    url: '/api/issuers/{tenantId}/chained-as-vp/authorize';
};
type ChainedAsVpControllerAuthorizeErrors = {
    400: ChainedAsErrorResponseDto;
};
type ChainedAsVpControllerAuthorizeError = ChainedAsVpControllerAuthorizeErrors[keyof ChainedAsVpControllerAuthorizeErrors];
type ChainedAsVpControllerVpCallbackData = {
    body?: never;
    path: {
        /**
         * Tenant identifier
         */
        tenantId: string;
    };
    query: {
        cas: string;
        response_code?: string;
        error?: string;
        error_description?: string;
    };
    url: '/api/issuers/{tenantId}/chained-as-vp/vp-callback';
};
type ChainedAsVpControllerVpCallbackErrors = {
    400: ChainedAsErrorResponseDto;
};
type ChainedAsVpControllerVpCallbackError = ChainedAsVpControllerVpCallbackErrors[keyof ChainedAsVpControllerVpCallbackErrors];
type ChainedAsVpControllerTokenData = {
    body: ChainedAsTokenRequestDto;
    headers?: {
        /**
         * DPoP proof JWT
         */
        DPoP?: string;
        /**
         * Wallet attestation JWT
         */
        'OAuth-Client-Attestation'?: string;
        /**
         * Wallet attestation proof-of-possession JWT
         */
        'OAuth-Client-Attestation-PoP'?: string;
    };
    path: {
        /**
         * Tenant identifier
         */
        tenantId: string;
    };
    query?: never;
    url: '/api/issuers/{tenantId}/chained-as-vp/token';
};
type ChainedAsVpControllerTokenErrors = {
    400: ChainedAsErrorResponseDto;
};
type ChainedAsVpControllerTokenError = ChainedAsVpControllerTokenErrors[keyof ChainedAsVpControllerTokenErrors];
type ChainedAsVpControllerTokenResponses = {
    200: ChainedAsTokenResponseDto;
};
type ChainedAsVpControllerTokenResponse = ChainedAsVpControllerTokenResponses[keyof ChainedAsVpControllerTokenResponses];
type VerifierOfferControllerGetOfferData = {
    body: PresentationRequest;
    path?: never;
    query?: never;
    url: '/api/verifier/offer';
};
type VerifierOfferControllerGetOfferResponses = {
    /**
     * JSON response
     */
    201: OfferResponse;
};
type VerifierOfferControllerGetOfferResponse = VerifierOfferControllerGetOfferResponses[keyof VerifierOfferControllerGetOfferResponses];
type StorageControllerUploadData = {
    body: FileUploadDto;
    path?: never;
    query?: never;
    url: '/api/storage';
};
type StorageControllerUploadResponses = {
    200: StoredObjectResponseDto;
};
type StorageControllerUploadResponse = StorageControllerUploadResponses[keyof StorageControllerUploadResponses];
type ConfigPortabilityControllerExportData = {
    body?: never;
    path?: never;
    query?: {
        format?: string;
    };
    url: '/api/config-bundles/export';
};
type ConfigPortabilityControllerExportResponses = {
    200: {
        [key: string]: unknown;
    };
};
type ConfigPortabilityControllerExportResponse = ConfigPortabilityControllerExportResponses[keyof ConfigPortabilityControllerExportResponses];
type ConfigPortabilityControllerPlanData = {
    body?: never;
    path?: never;
    query?: {
        mode?: string;
    };
    url: '/api/config-bundles/plan';
};
type ConfigPortabilityControllerPlanResponses = {
    201: {
        [key: string]: unknown;
    };
};
type ConfigPortabilityControllerPlanResponse = ConfigPortabilityControllerPlanResponses[keyof ConfigPortabilityControllerPlanResponses];
type ConfigPortabilityControllerPlanArchiveData = {
    body?: never;
    path?: never;
    query?: {
        mode?: string;
    };
    url: '/api/config-bundles/plan/archive';
};
type ConfigPortabilityControllerPlanArchiveResponses = {
    201: {
        [key: string]: unknown;
    };
};
type ConfigPortabilityControllerPlanArchiveResponse = ConfigPortabilityControllerPlanArchiveResponses[keyof ConfigPortabilityControllerPlanArchiveResponses];
type ConfigPortabilityControllerImportData = {
    body?: never;
    path?: never;
    query?: {
        mode?: string;
        confirmReplace?: string;
    };
    url: '/api/config-bundles/import';
};
type ConfigPortabilityControllerImportResponses = {
    201: {
        [key: string]: unknown;
    };
};
type ConfigPortabilityControllerImportResponse = ConfigPortabilityControllerImportResponses[keyof ConfigPortabilityControllerImportResponses];
type ConfigPortabilityControllerImportArchiveData = {
    body?: never;
    path?: never;
    query?: {
        mode?: string;
        confirmReplace?: string;
    };
    url: '/api/config-bundles/import/archive';
};
type ConfigPortabilityControllerImportArchiveResponses = {
    201: {
        [key: string]: unknown;
    };
};
type ConfigPortabilityControllerImportArchiveResponse = ConfigPortabilityControllerImportArchiveResponses[keyof ConfigPortabilityControllerImportArchiveResponses];
type ConfigPortabilityControllerUpgradeData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/config-bundles/documents/upgrade';
};
type ConfigPortabilityControllerUpgradeResponses = {
    201: unknown;
};
type ConfigPortabilityControllerResourcesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/config-bundles/resources';
};
type ConfigPortabilityControllerResourcesResponses = {
    200: Array<ConfigResourceMetadataEntity>;
};
type ConfigPortabilityControllerResourcesResponse = ConfigPortabilityControllerResourcesResponses[keyof ConfigPortabilityControllerResourcesResponses];
type ConfigPortabilityControllerDetachData = {
    body?: never;
    path: {
        kind: string;
        id: string;
    };
    query?: never;
    url: '/api/config-bundles/resources/{kind}/{id}/detach';
};
type ConfigPortabilityControllerDetachResponses = {
    201: ConfigResourceMetadataEntity;
};
type ConfigPortabilityControllerDetachResponse = ConfigPortabilityControllerDetachResponses[keyof ConfigPortabilityControllerDetachResponses];

export type { CacheControllerClearStatusListCacheResponses as $, AccessCertificateRefDto as A, AttributeProviderControllerUpdateResponse as B, ClientOptions as C, AttributeProviderControllerUpdateResponses as D, AttributeProviderEntity as E, AuditLogControllerGetAuditLogsData as F, AuditLogControllerGetAuditLogsResponse as G, AuditLogControllerGetAuditLogsResponses as H, AuditLogResponseDto as I, AuthControllerGetOAuth2TokenData as J, AuthControllerGetOAuth2TokenError as K, AuthControllerGetOAuth2TokenErrors as L, AuthControllerGetOAuth2TokenResponse as M, AuthControllerGetOAuth2TokenResponses as N, AuthenticationMethodAuth as O, AuthenticationMethodNone as P, AuthenticationMethodPresentation as Q, AuthenticationUrlConfig as R, Session as S, AuthorizationResponse as T, AuthorizeQueries as U, BuiltInAuthorizationServerConfig as V, CacheControllerClearAllCachesData as W, CacheControllerClearAllCachesResponse as X, CacheControllerClearAllCachesResponses as Y, CacheControllerClearStatusListCacheData as Z, CacheControllerClearStatusListCacheResponse as _, ActiveCredentialPolicy as a, ConfigPortabilityControllerImportArchiveData as a$, CacheControllerClearTrustListCacheData as a0, CacheControllerClearTrustListCacheResponse as a1, CacheControllerClearTrustListCacheResponses as a2, CacheControllerGetStatsData as a3, CacheControllerGetStatsResponse as a4, CacheControllerGetStatsResponses as a5, CacheStatsResponseDto as a6, CertificateInfoDto as a7, ChainedAsErrorResponseDto as a8, ChainedAsParRequestDto as a9, ClientControllerDeleteClientData as aA, ClientControllerDeleteClientResponse as aB, ClientControllerDeleteClientResponses as aC, ClientControllerGetClientData as aD, ClientControllerGetClientErrors as aE, ClientControllerGetClientResponse as aF, ClientControllerGetClientResponses as aG, ClientControllerGetClientsData as aH, ClientControllerGetClientsResponse as aI, ClientControllerGetClientsResponses as aJ, ClientControllerRotateClientSecretData as aK, ClientControllerRotateClientSecretResponse as aL, ClientControllerRotateClientSecretResponses as aM, ClientControllerUpdateClientData as aN, ClientControllerUpdateClientErrors as aO, ClientControllerUpdateClientResponse as aP, ClientControllerUpdateClientResponses as aQ, ClientCredentialsDto as aR, ClientEntity as aS, ClientSecretResponseDto as aT, CompleteDeferredDto as aU, ConfigPortabilityControllerDetachData as aV, ConfigPortabilityControllerDetachResponse as aW, ConfigPortabilityControllerDetachResponses as aX, ConfigPortabilityControllerExportData as aY, ConfigPortabilityControllerExportResponse as aZ, ConfigPortabilityControllerExportResponses as a_, ChainedAsParResponseDto as aa, ChainedAsTokenConfig as ab, ChainedAsTokenRequestDto as ac, ChainedAsTokenResponseDto as ad, ChainedAsVpControllerAuthorizeData as ae, ChainedAsVpControllerAuthorizeError as af, ChainedAsVpControllerAuthorizeErrors as ag, ChainedAsVpControllerParData as ah, ChainedAsVpControllerParError as ai, ChainedAsVpControllerParErrors as aj, ChainedAsVpControllerParResponse as ak, ChainedAsVpControllerParResponses as al, ChainedAsVpControllerTokenData as am, ChainedAsVpControllerTokenError as an, ChainedAsVpControllerTokenErrors as ao, ChainedAsVpControllerTokenResponse as ap, ChainedAsVpControllerTokenResponses as aq, ChainedAsVpControllerVpCallbackData as ar, ChainedAsVpControllerVpCallbackError as as, ChainedAsVpControllerVpCallbackErrors as at, ChainedAuthorizationServerConfig as au, ClaimFieldDefinitionDto as av, ClaimsQuery as aw, ClientControllerCreateClientData as ax, ClientControllerCreateClientResponse as ay, ClientControllerCreateClientResponses as az, AllowListPolicy as b, DeprecateSchemaMetadataDto as b$, ConfigPortabilityControllerImportArchiveResponse as b0, ConfigPortabilityControllerImportArchiveResponses as b1, ConfigPortabilityControllerImportData as b2, ConfigPortabilityControllerImportResponse as b3, ConfigPortabilityControllerImportResponses as b4, ConfigPortabilityControllerPlanArchiveData as b5, ConfigPortabilityControllerPlanArchiveResponse as b6, ConfigPortabilityControllerPlanArchiveResponses as b7, ConfigPortabilityControllerPlanData as b8, ConfigPortabilityControllerPlanResponse as b9, CredentialConfigControllerStoreCredentialConfigurationResponse as bA, CredentialConfigControllerStoreCredentialConfigurationResponses as bB, CredentialConfigControllerUpdateCredentialConfigurationData as bC, CredentialConfigControllerUpdateCredentialConfigurationResponse as bD, CredentialConfigControllerUpdateCredentialConfigurationResponses as bE, CredentialConfigCreate as bF, CredentialConfigUpdate as bG, CredentialIssuerMetadataDto as bH, CredentialOfferControllerGetOfferData as bI, CredentialOfferControllerGetOfferResponse as bJ, CredentialOfferControllerGetOfferResponses as bK, CredentialQueryDcSdJwt as bL, CredentialQueryMsoMdoc as bM, CredentialReusePolicy as bN, CredentialSetQuery as bO, DcSdJwtCredentialQueryMeta as bP, Dcql as bQ, DeferredControllerCompleteDeferredData as bR, DeferredControllerCompleteDeferredErrors as bS, DeferredControllerCompleteDeferredResponse as bT, DeferredControllerCompleteDeferredResponses as bU, DeferredControllerFailDeferredData as bV, DeferredControllerFailDeferredErrors as bW, DeferredControllerFailDeferredResponse as bX, DeferredControllerFailDeferredResponses as bY, DeferredCredentialRequestDto as bZ, DeferredOperationResponse as b_, ConfigPortabilityControllerPlanResponses as ba, ConfigPortabilityControllerResourcesData as bb, ConfigPortabilityControllerResourcesResponse as bc, ConfigPortabilityControllerResourcesResponses as bd, ConfigPortabilityControllerUpgradeData as be, ConfigPortabilityControllerUpgradeResponses as bf, ConfigResourceMetadataEntity as bg, CreateAccessCertificateDto as bh, CreateAttributeProviderDto as bi, CreateClientDto as bj, CreateRegistrarConfigDto as bk, CreateStatusListDto as bl, CreateTenantDto as bm, CreateUserDto as bn, CreateWebhookEndpointDto as bo, CredentialConfig as bp, CredentialConfigControllerDeleteIssuanceConfigurationData as bq, CredentialConfigControllerDeleteIssuanceConfigurationResponse as br, CredentialConfigControllerDeleteIssuanceConfigurationResponses as bs, CredentialConfigControllerGetConfigByIdData as bt, CredentialConfigControllerGetConfigByIdResponse as bu, CredentialConfigControllerGetConfigByIdResponses as bv, CredentialConfigControllerGetConfigsData as bw, CredentialConfigControllerGetConfigsResponse as bx, CredentialConfigControllerGetConfigsResponses as by, CredentialConfigControllerStoreCredentialConfigurationData as bz, ApiKeyConfig as c, KeyChainControllerGetByIdResponses as c$, Display as c0, DisplayImage as c1, DisplayInfo as c2, DisplayLogo as c3, EcJwk as c4, EcPublic as c5, EmbeddedDisclosurePolicy as c6, ExportEcJwk as c7, ExportRotationPolicyDto as c8, ExternalAuthorizationServerConfig as c9, IssuanceConfigWritable as cA, IssuerMetadataCredentialConfig as cB, IssuerOfferEntryDto as cC, IssuerRegistrationCertificateCache as cD, IssuerRegistrationCertificateConfig as cE, JwksResponseDto as cF, KeyAttestationsRequired as cG, KeyChainControllerCreateData as cH, KeyChainControllerCreateResponse as cI, KeyChainControllerCreateResponses as cJ, KeyChainControllerDeleteData as cK, KeyChainControllerDeleteErrors as cL, KeyChainControllerDeleteResponse as cM, KeyChainControllerDeleteResponses as cN, KeyChainControllerDeleteTenantKmsConfigData as cO, KeyChainControllerDeleteTenantKmsConfigResponse as cP, KeyChainControllerDeleteTenantKmsConfigResponses as cQ, KeyChainControllerExportData as cR, KeyChainControllerExportErrors as cS, KeyChainControllerExportResponse as cT, KeyChainControllerExportResponses as cU, KeyChainControllerGetAllData as cV, KeyChainControllerGetAllResponse as cW, KeyChainControllerGetAllResponses as cX, KeyChainControllerGetByIdData as cY, KeyChainControllerGetByIdErrors as cZ, KeyChainControllerGetByIdResponse as c_, ExternalTrustListEntity as ca, FailDeferredDto as cb, FederationConfig as cc, FederationTrustAnchorConfig as cd, FieldDisplayDto as ce, FileUploadDto as cf, FrontendConfigResponseDto as cg, GrafanaConfigDto as ch, IaeActionOpenid4VpPresentation as ci, IaeActionRedirectToWeb as cj, ImportTenantDto as ck, InteractiveAuthorizationCodeResponseDto as cl, InteractiveAuthorizationErrorResponseDto as cm, InteractiveAuthorizationRequestDto as cn, InternalTrustListEntity as co, IssuanceConfig as cp, IssuanceConfigControllerGetIssuanceConfigurationsData as cq, IssuanceConfigControllerGetIssuanceConfigurationsResponse as cr, IssuanceConfigControllerGetIssuanceConfigurationsResponses as cs, IssuanceConfigControllerReissueRegistrationCertificateData as ct, IssuanceConfigControllerReissueRegistrationCertificateErrors as cu, IssuanceConfigControllerReissueRegistrationCertificateResponse as cv, IssuanceConfigControllerReissueRegistrationCertificateResponses as cw, IssuanceConfigControllerStoreIssuanceConfigurationData as cx, IssuanceConfigControllerStoreIssuanceConfigurationResponse as cy, IssuanceConfigControllerStoreIssuanceConfigurationResponses as cz, AppControllerGetFrontendConfigData as d, PresentationManagementControllerDeleteConfigurationResponse as d$, KeyChainControllerGetProvidersData as d0, KeyChainControllerGetProvidersHealthData as d1, KeyChainControllerGetProvidersHealthResponse as d2, KeyChainControllerGetProvidersHealthResponses as d3, KeyChainControllerGetProvidersResponse as d4, KeyChainControllerGetProvidersResponses as d5, KeyChainControllerGetTenantKmsConfigData as d6, KeyChainControllerGetTenantKmsConfigResponse as d7, KeyChainControllerGetTenantKmsConfigResponses as d8, KeyChainControllerImportData as d9, KmsTenantConfigResponseDto as dA, ManagedAuthorizationServerConfig as dB, ManagedUserDto as dC, MetadataSchemaDto as dD, MsoMdocClaimsQuery as dE, MsoMdocCredentialQueryMeta as dF, NoneTrustPolicy as dG, NotificationRequestDto as dH, OAuthTokenErrorResponseDto as dI, Object$1 as dJ, ObjectWritable as dK, OfferRequestDto as dL, OfferResponse as dM, Oid4VpAuthorizationServerConfig as dN, PaginatedSessionResponseDto as dO, ParResponseDto as dP, PolicyCredential as dQ, PresentationAttachment as dR, PresentationConfig as dS, PresentationConfigCreateDto as dT, PresentationConfigUpdateDto as dU, PresentationConfigWritable as dV, PresentationDuringIssuanceConfig as dW, PresentationManagementControllerConfigurationData as dX, PresentationManagementControllerConfigurationResponse as dY, PresentationManagementControllerConfigurationResponses as dZ, PresentationManagementControllerDeleteConfigurationData as d_, KeyChainControllerImportResponse as da, KeyChainControllerImportResponses as db, KeyChainControllerRotateData as dc, KeyChainControllerRotateErrors as dd, KeyChainControllerRotateResponse as de, KeyChainControllerRotateResponses as df, KeyChainControllerUpdateData as dg, KeyChainControllerUpdateErrors as dh, KeyChainControllerUpdateResponse as di, KeyChainControllerUpdateResponses as dj, KeyChainControllerUpdateTenantKmsConfigData as dk, KeyChainControllerUpdateTenantKmsConfigResponse as dl, KeyChainControllerUpdateTenantKmsConfigResponses as dm, KeyChainCreateDto as dn, KeyChainEntity as dp, KeyChainExportDto as dq, KeyChainIdResponseDto as dr, KeyChainImportDto as ds, KeyChainResponseDto as dt, KeyChainUpdateDto as du, KeyResponseDto as dv, KmsConfigDto as dw, KmsProviderCapabilitiesDto as dx, KmsProviderInfoDto as dy, KmsProvidersResponseDto as dz, AppControllerGetFrontendConfigResponse as e, ResolvedSchemaMetadataTrustedAuthorityDto as e$, PresentationManagementControllerDeleteConfigurationResponses as e0, PresentationManagementControllerGetConfigurationData as e1, PresentationManagementControllerGetConfigurationResponse as e2, PresentationManagementControllerGetConfigurationResponses as e3, PresentationManagementControllerListSchemaMetadataCatalogData as e4, PresentationManagementControllerListSchemaMetadataCatalogResponse as e5, PresentationManagementControllerListSchemaMetadataCatalogResponses as e6, PresentationManagementControllerReissueRegistrationCertificateData as e7, PresentationManagementControllerReissueRegistrationCertificateErrors as e8, PresentationManagementControllerReissueRegistrationCertificateResponse as e9, RegistrarControllerCreateAccessCertificateResponses as eA, RegistrarControllerCreateConfigData as eB, RegistrarControllerCreateConfigErrors as eC, RegistrarControllerCreateConfigResponse as eD, RegistrarControllerCreateConfigResponses as eE, RegistrarControllerDeleteConfigData as eF, RegistrarControllerDeleteConfigResponse as eG, RegistrarControllerDeleteConfigResponses as eH, RegistrarControllerGetConfigData as eI, RegistrarControllerGetConfigErrors as eJ, RegistrarControllerGetConfigResponse as eK, RegistrarControllerGetConfigResponses as eL, RegistrarControllerUpdateConfigData as eM, RegistrarControllerUpdateConfigErrors as eN, RegistrarControllerUpdateConfigResponse as eO, RegistrarControllerUpdateConfigResponses as eP, RegistrationCertificateBody as eQ, RegistrationCertificateDefaults as eR, RegistrationCertificatePurpose as eS, RegistrationCertificateRequest as eT, ResolveIssuerMetadataDto as eU, ResolveSchemaMetadataDto as eV, ResolveSchemaMetadataJwtDto as eW, ResolvedSchemaMetadataReferenceDto as eX, ResolvedSchemaMetadataResponseDto as eY, ResolvedSchemaMetadataSchemaDto as eZ, ResolvedSchemaMetadataSchemaUriDto as e_, PresentationManagementControllerReissueRegistrationCertificateResponses as ea, PresentationManagementControllerResolveIssuerMetadataData as eb, PresentationManagementControllerResolveIssuerMetadataErrors as ec, PresentationManagementControllerResolveIssuerMetadataResponse as ed, PresentationManagementControllerResolveIssuerMetadataResponses as ee, PresentationManagementControllerResolveSchemaMetadataData as ef, PresentationManagementControllerResolveSchemaMetadataErrors as eg, PresentationManagementControllerResolveSchemaMetadataJwtData as eh, PresentationManagementControllerResolveSchemaMetadataJwtErrors as ei, PresentationManagementControllerResolveSchemaMetadataJwtResponse as ej, PresentationManagementControllerResolveSchemaMetadataJwtResponses as ek, PresentationManagementControllerResolveSchemaMetadataResponse as el, PresentationManagementControllerResolveSchemaMetadataResponses as em, PresentationManagementControllerStorePresentationConfigData as en, PresentationManagementControllerStorePresentationConfigResponse as eo, PresentationManagementControllerStorePresentationConfigResponses as ep, PresentationManagementControllerUpdateConfigurationData as eq, PresentationManagementControllerUpdateConfigurationResponse as er, PresentationManagementControllerUpdateConfigurationResponses as es, PresentationRequest as et, ProviderHealthResponseDto as eu, PublicKeyInfoDto as ev, RegistrarConfigResponseDto as ew, RegistrarControllerCreateAccessCertificateData as ex, RegistrarControllerCreateAccessCertificateErrors as ey, RegistrarControllerCreateAccessCertificateResponse as ez, AppControllerGetFrontendConfigResponses as f, SessionControllerDeleteSessionResponses as f$, RoleDto as f0, RootOfTrustPolicy as f1, RotationPolicyCreateDto as f2, RotationPolicyImportDto as f3, RotationPolicyResponseDto as f4, RotationPolicyUpdateDto as f5, SchemaMetaConfig as f6, SchemaMetadataControllerDeprecateVersionData as f7, SchemaMetadataControllerDeprecateVersionResponse as f8, SchemaMetadataControllerDeprecateVersionResponses as f9, SchemaMetadataControllerPublishSchemaMetadataResponse as fA, SchemaMetadataControllerPublishSchemaMetadataResponses as fB, SchemaMetadataControllerPublishSchemaMetadataVersionData as fC, SchemaMetadataControllerPublishSchemaMetadataVersionErrors as fD, SchemaMetadataControllerPublishSchemaMetadataVersionResponse as fE, SchemaMetadataControllerPublishSchemaMetadataVersionResponses as fF, SchemaMetadataControllerRemoveData as fG, SchemaMetadataControllerRemoveResponse as fH, SchemaMetadataControllerRemoveResponses as fI, SchemaMetadataControllerUpdateData as fJ, SchemaMetadataControllerUpdateResponse as fK, SchemaMetadataControllerUpdateResponses as fL, SchemaMetadataResponseDto as fM, SchemaMetadataVocabulariesDto as fN, SchemaUriEntry as fO, ServiceInfoResponseDto as fP, SessionConfigControllerGetConfigData as fQ, SessionConfigControllerGetConfigResponse as fR, SessionConfigControllerGetConfigResponses as fS, SessionConfigControllerResetConfigData as fT, SessionConfigControllerResetConfigResponse as fU, SessionConfigControllerResetConfigResponses as fV, SessionConfigControllerUpdateConfigData as fW, SessionConfigControllerUpdateConfigResponse as fX, SessionConfigControllerUpdateConfigResponses as fY, SessionControllerDeleteSessionData as fZ, SessionControllerDeleteSessionResponse as f_, SchemaMetadataControllerFindAllData as fa, SchemaMetadataControllerFindAllResponse as fb, SchemaMetadataControllerFindAllResponses as fc, SchemaMetadataControllerFindOneData as fd, SchemaMetadataControllerFindOneResponse as fe, SchemaMetadataControllerFindOneResponses as ff, SchemaMetadataControllerGetJwtData as fg, SchemaMetadataControllerGetJwtResponse as fh, SchemaMetadataControllerGetJwtResponses as fi, SchemaMetadataControllerGetLatestData as fj, SchemaMetadataControllerGetLatestResponse as fk, SchemaMetadataControllerGetLatestResponses as fl, SchemaMetadataControllerGetMineData as fm, SchemaMetadataControllerGetMineResponse as fn, SchemaMetadataControllerGetMineResponses as fo, SchemaMetadataControllerGetSchemaData as fp, SchemaMetadataControllerGetSchemaResponse as fq, SchemaMetadataControllerGetSchemaResponses as fr, SchemaMetadataControllerGetVersionsData as fs, SchemaMetadataControllerGetVersionsResponse as ft, SchemaMetadataControllerGetVersionsResponses as fu, SchemaMetadataControllerGetVocabulariesData as fv, SchemaMetadataControllerGetVocabulariesResponse as fw, SchemaMetadataControllerGetVocabulariesResponses as fx, SchemaMetadataControllerPublishSchemaMetadataData as fy, SchemaMetadataControllerPublishSchemaMetadataErrors as fz, AppControllerGetVersionData as g, TenantControllerInitTenantData as g$, SessionControllerGetAllSessionsData as g0, SessionControllerGetAllSessionsResponse as g1, SessionControllerGetAllSessionsResponses as g2, SessionControllerGetSessionData as g3, SessionControllerGetSessionLogsData as g4, SessionControllerGetSessionLogsResponse as g5, SessionControllerGetSessionLogsResponses as g6, SessionControllerGetSessionResponse as g7, SessionControllerGetSessionResponses as g8, SessionControllerRevokeAllData as g9, StatusListManagementControllerDeleteListResponse as gA, StatusListManagementControllerDeleteListResponses as gB, StatusListManagementControllerGetListData as gC, StatusListManagementControllerGetListResponse as gD, StatusListManagementControllerGetListResponses as gE, StatusListManagementControllerGetListsData as gF, StatusListManagementControllerGetListsResponse as gG, StatusListManagementControllerGetListsResponses as gH, StatusListManagementControllerUpdateListData as gI, StatusListManagementControllerUpdateListResponse as gJ, StatusListManagementControllerUpdateListResponses as gK, StatusListResponseDto as gL, StatusUpdateDto as gM, StorageControllerUploadData as gN, StorageControllerUploadResponse as gO, StorageControllerUploadResponses as gP, StoredObjectResponseDto as gQ, TenantClientCredentialsDto as gR, TenantControllerDeleteTenantData as gS, TenantControllerDeleteTenantResponse as gT, TenantControllerDeleteTenantResponses as gU, TenantControllerGetTenantData as gV, TenantControllerGetTenantResponse as gW, TenantControllerGetTenantResponses as gX, TenantControllerGetTenantsData as gY, TenantControllerGetTenantsResponse as gZ, TenantControllerGetTenantsResponses as g_, SessionControllerRevokeAllResponse as ga, SessionControllerRevokeAllResponses as gb, SessionEventsControllerSubscribeToSessionEventsData as gc, SessionEventsControllerSubscribeToSessionEventsResponse as gd, SessionEventsControllerSubscribeToSessionEventsResponses as ge, SessionLogEntryResponseDto as gf, SessionStorageConfig as gg, SignSchemaMetaConfigDto as gh, SignVersionSchemaMetaConfigDto as gi, StatusListAggregationDto as gj, StatusListCacheStatsDto as gk, StatusListConfig as gl, StatusListConfigControllerGetConfigData as gm, StatusListConfigControllerGetConfigResponse as gn, StatusListConfigControllerGetConfigResponses as go, StatusListConfigControllerResetConfigData as gp, StatusListConfigControllerResetConfigResponse as gq, StatusListConfigControllerResetConfigResponses as gr, StatusListConfigControllerUpdateConfigData as gs, StatusListConfigControllerUpdateConfigResponse as gt, StatusListConfigControllerUpdateConfigResponses as gu, StatusListImportDto as gv, StatusListManagementControllerCreateListData as gw, StatusListManagementControllerCreateListResponse as gx, StatusListManagementControllerCreateListResponses as gy, StatusListManagementControllerDeleteListData as gz, AppControllerGetVersionResponse as h, UserControllerDeleteUserResponses as h$, TenantControllerInitTenantResponse as h0, TenantControllerInitTenantResponses as h1, TenantControllerUpdateTenantData as h2, TenantControllerUpdateTenantResponse as h3, TenantControllerUpdateTenantResponses as h4, TenantCreateResponseDto as h5, TenantEntity as h6, TenantResponseDto as h7, TokenResponse as h8, TransactionData as h9, TrustListControllerUpdateTrustListResponse as hA, TrustListControllerUpdateTrustListResponses as hB, TrustListCreateDto as hC, TrustListEntityInfo as hD, TrustListRef as hE, TrustListVersion as hF, TrustedAuthorityQueryEtsiTl as hG, TrustedAuthorityQueryOpenIdFederation as hH, UpdateAttributeProviderDto as hI, UpdateClientDto as hJ, UpdateIssuanceDto as hK, UpdateIssuanceDtoWritable as hL, UpdateIssuerOfferDto as hM, UpdateRegistrarConfigDto as hN, UpdateSchemaMetadataDto as hO, UpdateSessionConfigDto as hP, UpdateStatusListConfigDto as hQ, UpdateStatusListDto as hR, UpdateTenantDto as hS, UpdateUserDto as hT, UpdateWebhookEndpointDto as hU, UpstreamOidcConfig as hV, UserControllerCreateUserData as hW, UserControllerCreateUserResponse as hX, UserControllerCreateUserResponses as hY, UserControllerDeleteUserData as hZ, UserControllerDeleteUserResponse as h_, TrustAuthorityDto as ha, TrustAuthorityEntry as hb, TrustList as hc, TrustListCacheStatsDto as hd, TrustListControllerCreateTrustListData as he, TrustListControllerCreateTrustListResponse as hf, TrustListControllerCreateTrustListResponses as hg, TrustListControllerDeleteTrustListData as hh, TrustListControllerDeleteTrustListResponse as hi, TrustListControllerDeleteTrustListResponses as hj, TrustListControllerExportTrustListData as hk, TrustListControllerExportTrustListResponse as hl, TrustListControllerExportTrustListResponses as hm, TrustListControllerGetAllTrustListsData as hn, TrustListControllerGetAllTrustListsResponse as ho, TrustListControllerGetAllTrustListsResponses as hp, TrustListControllerGetTrustListData as hq, TrustListControllerGetTrustListResponse as hr, TrustListControllerGetTrustListResponses as hs, TrustListControllerGetTrustListVersionData as ht, TrustListControllerGetTrustListVersionResponse as hu, TrustListControllerGetTrustListVersionResponses as hv, TrustListControllerGetTrustListVersionsData as hw, TrustListControllerGetTrustListVersionsResponse as hx, TrustListControllerGetTrustListVersionsResponses as hy, TrustListControllerUpdateTrustListData as hz, AppControllerGetVersionResponses as i, UserControllerGetUserData as i0, UserControllerGetUserResponse as i1, UserControllerGetUserResponses as i2, UserControllerGetUsersData as i3, UserControllerGetUsersResponse as i4, UserControllerGetUsersResponses as i5, UserControllerUpdateUserData as i6, UserControllerUpdateUserResponse as i7, UserControllerUpdateUserResponses as i8, Vct as i9, WebhookEndpointControllerUpdateErrors as iA, WebhookEndpointControllerUpdateResponse as iB, WebhookEndpointControllerUpdateResponses as iC, WebhookEndpointEntity as iD, VerifierOfferControllerGetOfferData as ia, VerifierOfferControllerGetOfferResponse as ib, VerifierOfferControllerGetOfferResponses as ic, VersionResponseDto as id, VocabularyEntryDto as ie, WalletProviderTrustListRefDto as ig, WebHookAuthConfigHeader as ih, WebHookAuthConfigNone as ii, WebhookConfig as ij, WebhookEndpointControllerCreateData as ik, WebhookEndpointControllerCreateResponse as il, WebhookEndpointControllerCreateResponses as im, WebhookEndpointControllerDeleteData as io, WebhookEndpointControllerDeleteErrors as ip, WebhookEndpointControllerDeleteResponse as iq, WebhookEndpointControllerDeleteResponses as ir, WebhookEndpointControllerGetAllData as is, WebhookEndpointControllerGetAllResponse as it, WebhookEndpointControllerGetAllResponses as iu, WebhookEndpointControllerGetByIdData as iv, WebhookEndpointControllerGetByIdErrors as iw, WebhookEndpointControllerGetByIdResponse as ix, WebhookEndpointControllerGetByIdResponses as iy, WebhookEndpointControllerUpdateData as iz, AttestationBasedPolicy as j, AttributeProviderControllerCreateData as k, AttributeProviderControllerCreateResponse as l, AttributeProviderControllerCreateResponses as m, AttributeProviderControllerDeleteData as n, AttributeProviderControllerDeleteErrors as o, AttributeProviderControllerDeleteResponse as p, AttributeProviderControllerDeleteResponses as q, AttributeProviderControllerGetAllData as r, AttributeProviderControllerGetAllResponse as s, AttributeProviderControllerGetAllResponses as t, AttributeProviderControllerGetByIdData as u, AttributeProviderControllerGetByIdErrors as v, AttributeProviderControllerGetByIdResponse as w, AttributeProviderControllerGetByIdResponses as x, AttributeProviderControllerUpdateData as y, AttributeProviderControllerUpdateErrors as z };