import { CredentialMultiInstanceUseMode } from "../../utils/credentialUseTypes.mjs";
import { MdocSessionTranscriptOptions } from "../mdoc/MdocOptions.mjs";
import "../mdoc/index.mjs";
import { VerifiablePresentation } from "../dif-presentation-exchange/models/index.mjs";
import "../dif-presentation-exchange/index.mjs";
import { AgentContext } from "../../agent/context/AgentContext.mjs";
import "../../agent/index.mjs";
import "../../utils/credentialUse.mjs";
import { DcqlCredentialsForRequest } from "./models/DcqlCredentialsForRequest.mjs";
import { DcqlEncodedPresentations, DcqlPresentation, DcqlQueryResult as DcqlQueryResult$1 } from "./models/index.mjs";
import { DcqlCredential, DcqlQuery } from "dcql";
//#region src/modules/dcql/DcqlService.d.ts
export interface DcqlSelectCredentialsForRequestOptions {
  /**
   * The usage mode to apply to the credentials when selecting credentials.
   *
   * If an usage mode is selected that require a new instance to be used, and there's no
   * new instances available, an error will be thrown.
   *
   * It does not actually select the credential from the record yet, it just filters
   *  out records that don't match the filter.
   */
  useMode?: CredentialMultiInstanceUseMode;
}
export declare class DcqlService {
  /**
   * Queries the wallet for credentials that match the given dcql query. This only does an initial query based on the
   * schema of the input descriptors. It does not do any further filtering based on the constraints in the input descriptors.
   */
  private queryCredentialsForDcqlQuery;
  private getAuthorityForCredential;
  getDcqlCredentialRepresentation(agentContext: AgentContext, presentation: VerifiablePresentation, queryCredential: DcqlQuery['credentials'][number]): Promise<DcqlCredential>;
  getCredentialsForRequest(agentContext: AgentContext, dcqlQuery: DcqlQuery): Promise<DcqlQueryResult$1>;
  /**
   * What a selectively disclosable credential discloses for the output of a claim set.
   *
   * The output of DCQL only holds the requested claims, while a claim that is not selectively
   * disclosable is always disclosed. So the output is replaced with the claims as the verifier receives
   * them, and `disclosed_paths` added: the paths to those claims in the credential, which are what to
   * disclose when presenting it.
   *
   * Other credentials disclose the output as it is.
   */
  private getDisclosedClaimSetOutput;
  assertValidDcqlPresentation(agentContext: AgentContext, dcqlPresentation: DcqlPresentation, dcqlQuery: DcqlQuery): Promise<{
    credential_matches: {
      [x: string]: {
        success: true;
        credential_query_id: string;
        valid_credentials: import("dcql").NonEmptyArray<{
          success: true;
          input_credential_index: number;
          trusted_authorities: {
            success: true;
            valid_trusted_authority?: undefined;
            failed_trusted_authorities?: undefined;
          } | {
            success: true;
            valid_trusted_authority: {
              success: true;
              trusted_authority_index: number;
              output: {
                type: "aki" | "etsi_tl" | "openid_federation";
                value: string;
              };
            };
            failed_trusted_authorities?: import("dcql").NonEmptyArray<{
              success: false;
              trusted_authority_index: number;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
          };
          claims: {
            success: true;
            valid_claims?: import("dcql").NonEmptyArray<{
              success: true;
              claim_index: number;
              claim_id?: string | undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }> | undefined;
            failed_claims?: import("dcql").NonEmptyArray<{
              success: false;
              claim_index: number;
              claim_id?: string | undefined;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
            valid_claim_sets: import("dcql").NonEmptyArray<{
              success: true;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes?: undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }>;
            failed_claim_sets?: import("dcql").NonEmptyArray<{
              success: false;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes: import("dcql").NonEmptyArray<number>;
              issues: {
                [x: string]: unknown;
              };
            }> | undefined;
          };
          meta: {
            success: true;
            output: {
              cryptographic_holder_binding: boolean;
              credential_format: "mso_mdoc";
              doctype: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "dc+sd-jwt" | "vc+sd-jwt";
              vct: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "jwt_vc_json" | "ldp_vc" | "vc+sd-jwt";
              type: string[];
            };
          };
        }>;
        failed_credentials?: import("dcql").NonEmptyArray<{
          success: false;
          input_credential_index: number;
          trusted_authorities: {
            success: true;
            valid_trusted_authority?: undefined;
            failed_trusted_authorities?: undefined;
          } | {
            success: true;
            valid_trusted_authority: {
              success: true;
              trusted_authority_index: number;
              output: {
                type: "aki" | "etsi_tl" | "openid_federation";
                value: string;
              };
            };
            failed_trusted_authorities?: import("dcql").NonEmptyArray<{
              success: false;
              trusted_authority_index: number;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
          } | {
            success: false;
            valid_trusted_authority?: undefined;
            failed_trusted_authorities: import("dcql").NonEmptyArray<{
              success: false;
              trusted_authority_index: number;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }>;
          };
          claims: {
            success: true;
            valid_claims?: import("dcql").NonEmptyArray<{
              success: true;
              claim_index: number;
              claim_id?: string | undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }> | undefined;
            failed_claims?: import("dcql").NonEmptyArray<{
              success: false;
              claim_index: number;
              claim_id?: string | undefined;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
            valid_claim_sets: import("dcql").NonEmptyArray<{
              success: true;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes?: undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }>;
            failed_claim_sets?: import("dcql").NonEmptyArray<{
              success: false;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes: import("dcql").NonEmptyArray<number>;
              issues: {
                [x: string]: unknown;
              };
            }> | undefined;
          } | {
            success: false;
            valid_claims?: import("dcql").NonEmptyArray<{
              success: true;
              claim_index: number;
              claim_id?: string | undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }> | undefined;
            failed_claims: import("dcql").NonEmptyArray<{
              success: false;
              claim_index: number;
              claim_id?: string | undefined;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }>;
            valid_claim_sets?: undefined;
            failed_claim_sets: import("dcql").NonEmptyArray<{
              success: false;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes: import("dcql").NonEmptyArray<number>;
              issues: {
                [x: string]: unknown;
              };
            }>;
          };
          meta: {
            success: true;
            output: {
              cryptographic_holder_binding: boolean;
              credential_format: "mso_mdoc";
              doctype: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "dc+sd-jwt" | "vc+sd-jwt";
              vct: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "jwt_vc_json" | "ldp_vc" | "vc+sd-jwt";
              type: string[];
            };
          } | {
            success: false;
            issues: {
              [x: string]: unknown;
            };
            output: unknown;
          };
        }> | undefined;
      } | {
        success: false;
        credential_query_id: string;
        valid_credentials?: undefined;
        failed_credentials?: import("dcql").NonEmptyArray<{
          success: false;
          input_credential_index: number;
          trusted_authorities: {
            success: true;
            valid_trusted_authority?: undefined;
            failed_trusted_authorities?: undefined;
          } | {
            success: true;
            valid_trusted_authority: {
              success: true;
              trusted_authority_index: number;
              output: {
                type: "aki" | "etsi_tl" | "openid_federation";
                value: string;
              };
            };
            failed_trusted_authorities?: import("dcql").NonEmptyArray<{
              success: false;
              trusted_authority_index: number;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
          } | {
            success: false;
            valid_trusted_authority?: undefined;
            failed_trusted_authorities: import("dcql").NonEmptyArray<{
              success: false;
              trusted_authority_index: number;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }>;
          };
          claims: {
            success: true;
            valid_claims?: import("dcql").NonEmptyArray<{
              success: true;
              claim_index: number;
              claim_id?: string | undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }> | undefined;
            failed_claims?: import("dcql").NonEmptyArray<{
              success: false;
              claim_index: number;
              claim_id?: string | undefined;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }> | undefined;
            valid_claim_sets: import("dcql").NonEmptyArray<{
              success: true;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes?: undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }>;
            failed_claim_sets?: import("dcql").NonEmptyArray<{
              success: false;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes: import("dcql").NonEmptyArray<number>;
              issues: {
                [x: string]: unknown;
              };
            }> | undefined;
          } | {
            success: false;
            valid_claims?: import("dcql").NonEmptyArray<{
              success: true;
              claim_index: number;
              claim_id?: string | undefined;
              output: {
                [x: string]: {
                  [x: string]: unknown;
                };
              } | {
                [x: string]: import("dcql").Json;
              };
            }> | undefined;
            failed_claims: import("dcql").NonEmptyArray<{
              success: false;
              claim_index: number;
              claim_id?: string | undefined;
              issues: {
                [x: string]: unknown;
              };
              output: unknown;
            }>;
            valid_claim_sets?: undefined;
            failed_claim_sets: import("dcql").NonEmptyArray<{
              success: false;
              claim_set_index: number | undefined;
              valid_claim_indexes?: import("dcql").NonEmptyArray<number> | undefined;
              failed_claim_indexes: import("dcql").NonEmptyArray<number>;
              issues: {
                [x: string]: unknown;
              };
            }>;
          };
          meta: {
            success: true;
            output: {
              cryptographic_holder_binding: boolean;
              credential_format: "mso_mdoc";
              doctype: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "dc+sd-jwt" | "vc+sd-jwt";
              vct: string;
            } | {
              cryptographic_holder_binding: boolean;
              credential_format: "jwt_vc_json" | "ldp_vc" | "vc+sd-jwt";
              type: string[];
            };
          } | {
            success: false;
            issues: {
              [x: string]: unknown;
            };
            output: unknown;
          };
        }> | undefined;
      };
    };
    credential_sets?: import("dcql").NonEmptyArray<{
      options: import("dcql").NonEmptyArray<string[]>;
      required: boolean;
      purpose?: string | number | {
        [x: string]: unknown;
      } | undefined;
      matching_options: import("dcql").NonEmptyArray<string[]> | undefined;
    }> | undefined;
    can_be_satisfied: boolean;
  }>;
  private getSelectiveDisclosure;
  private dcqlCredentialForRequestForValidCredential;
  /**
   * Selects the credentials to use based on the output from `getCredentialsForRequest`
   * Use this method if you don't want to manually select the credentials yourself.
   */
  selectCredentialsForRequest(dcqlQueryResult: DcqlQueryResult$1, { useMode }?: DcqlSelectCredentialsForRequestOptions): DcqlCredentialsForRequest;
  validateDcqlQuery(dcqlQuery: DcqlQuery | DcqlQuery.Input | unknown): DcqlQuery;
  createPresentation(agentContext: AgentContext, options: {
    credentialQueryToCredential: DcqlCredentialsForRequest;
    challenge: string;
    domain?: string;
    mdocSessionTranscript?: MdocSessionTranscriptOptions;
  }): Promise<{
    dcqlPresentation: DcqlPresentation;
    encodedDcqlPresentation: DcqlEncodedPresentations;
  }>;
  private getPresentationFrame;
  private getSdJwtVcApi;
  private getMdocApi;
  private getVerificationMethodForSubjectId;
  private getProofTypeForLdpVc;
}
//#endregion
//# sourceMappingURL=DcqlService.d.mts.map