/* tslint:disable */
/* eslint-disable */
/**
 * CredentialIssuanceService
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 1.0.0
 * Contact: info@affinidi.com
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

import type { Configuration } from './configuration'
import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios'
import globalAxios from 'axios'
// Some imports not used depending on template conditions
// @ts-ignore
import {
  DUMMY_BASE_URL,
  assertParamExists,
  setApiKeyToObject,
  setBasicAuthToObject,
  setBearerAuthToObject,
  setOAuthToObject,
  setSearchParams,
  serializeDataIfNeeded,
  toPathString,
  createRequestFunction,
} from './common'
import type { RequestArgs } from './base'
// @ts-ignore
import {
  BASE_PATH,
  COLLECTION_FORMATS,
  BaseAPI,
  RequiredError,
  operationServerMap,
} from './base'

/**
 *
 * @export
 * @interface ActionForbiddenError
 */
export interface ActionForbiddenError {
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenError
   */
  name: ActionForbiddenErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenError
   */
  message: ActionForbiddenErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof ActionForbiddenError
   */
  httpStatusCode: ActionForbiddenErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof ActionForbiddenError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const ActionForbiddenErrorNameEnum = {
  ActionForbiddenError: 'ActionForbiddenError',
} as const

export type ActionForbiddenErrorNameEnum =
  (typeof ActionForbiddenErrorNameEnum)[keyof typeof ActionForbiddenErrorNameEnum]
export const ActionForbiddenErrorMessageEnum = {
  PrincipalCanNotExecuteActionOnGivenResource:
    'Principal can not execute action on given resource',
} as const

export type ActionForbiddenErrorMessageEnum =
  (typeof ActionForbiddenErrorMessageEnum)[keyof typeof ActionForbiddenErrorMessageEnum]
export const ActionForbiddenErrorHttpStatusCodeEnum = {
  NUMBER_403: 403,
} as const

export type ActionForbiddenErrorHttpStatusCodeEnum =
  (typeof ActionForbiddenErrorHttpStatusCodeEnum)[keyof typeof ActionForbiddenErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface ActionForbiddenErrorDetailsInner
 */
export interface ActionForbiddenErrorDetailsInner {
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenErrorDetailsInner
   */
  issue: string
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenErrorDetailsInner
   */
  field?: string
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenErrorDetailsInner
   */
  value?: string
  /**
   *
   * @type {string}
   * @memberof ActionForbiddenErrorDetailsInner
   */
  location?: string
}
/**
 *
 * @export
 * @interface BatchCredentialInput
 */
export interface BatchCredentialInput {
  /**
   * Array that contains Credential Request objects.
   * @type {Array<BatchCredentialInputCredentialRequestsInner>}
   * @memberof BatchCredentialInput
   */
  credential_requests: Array<BatchCredentialInputCredentialRequestsInner>
}
/**
 *
 * @export
 * @interface BatchCredentialInputCredentialRequestsInner
 */
export interface BatchCredentialInputCredentialRequestsInner {
  /**
   * It is a String that identifies a Credential that is being requested to be issued.
   * @type {string}
   * @memberof BatchCredentialInputCredentialRequestsInner
   */
  credential_identifier?: string
  /**
   *
   * @type {CredentialProof}
   * @memberof BatchCredentialInputCredentialRequestsInner
   */
  proof: CredentialProof
}
/**
 *
 * @export
 * @interface BatchCredentialResponse
 */
export interface BatchCredentialResponse {
  /**
   *
   * @type {Array<BatchCredentialResponseCredentialResponsesInner>}
   * @memberof BatchCredentialResponse
   */
  credential_responses: Array<BatchCredentialResponseCredentialResponsesInner>
  /**
   *
   * @type {string}
   * @memberof BatchCredentialResponse
   */
  c_nonce?: string
  /**
   * Expiration time in seconds
   * @type {number}
   * @memberof BatchCredentialResponse
   */
  c_nonce_expires_in?: number
}
/**
 *
 * @export
 * @interface BatchCredentialResponseCredentialResponsesInner
 */
export interface BatchCredentialResponseCredentialResponsesInner {
  /**
   * Issued Credential, It can be a string or an object, depending on the Credential format. default format  is `ldp_vc`.
   * @type {any}
   * @memberof BatchCredentialResponseCredentialResponsesInner
   */
  credential: any
}
/**
 * @type ChangeCredentialStatus400Response
 * @export
 */
export type ChangeCredentialStatus400Response =
  | ChangeStatusForbiddenError
  | InvalidParameterError

/**
 *
 * @export
 * @interface ChangeCredentialStatusInput
 */
export interface ChangeCredentialStatusInput {
  /**
   * reason for revocation
   * @type {string}
   * @memberof ChangeCredentialStatusInput
   */
  changeReason?: ChangeCredentialStatusInputChangeReasonEnum
  /**
   *
   * @type {string}
   * @memberof ChangeCredentialStatusInput
   */
  issuanceRecordId?: string
}

export const ChangeCredentialStatusInputChangeReasonEnum = {
  InvalidCredential: 'INVALID_CREDENTIAL',
  CompromisedIssuer: 'COMPROMISED_ISSUER',
} as const

export type ChangeCredentialStatusInputChangeReasonEnum =
  (typeof ChangeCredentialStatusInputChangeReasonEnum)[keyof typeof ChangeCredentialStatusInputChangeReasonEnum]

/**
 *
 * @export
 * @interface ChangeStatusForbiddenError
 */
export interface ChangeStatusForbiddenError {
  /**
   *
   * @type {string}
   * @memberof ChangeStatusForbiddenError
   */
  name: ChangeStatusForbiddenErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof ChangeStatusForbiddenError
   */
  message: ChangeStatusForbiddenErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof ChangeStatusForbiddenError
   */
  httpStatusCode: ChangeStatusForbiddenErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof ChangeStatusForbiddenError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof ChangeStatusForbiddenError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const ChangeStatusForbiddenErrorNameEnum = {
  ChangeStatusForbiddenError: 'ChangeStatusForbiddenError',
} as const

export type ChangeStatusForbiddenErrorNameEnum =
  (typeof ChangeStatusForbiddenErrorNameEnum)[keyof typeof ChangeStatusForbiddenErrorNameEnum]
export const ChangeStatusForbiddenErrorMessageEnum = {
  RelatedVcStatusCannotBeChanged: 'Related VC status cannot be changed',
} as const

export type ChangeStatusForbiddenErrorMessageEnum =
  (typeof ChangeStatusForbiddenErrorMessageEnum)[keyof typeof ChangeStatusForbiddenErrorMessageEnum]
export const ChangeStatusForbiddenErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type ChangeStatusForbiddenErrorHttpStatusCodeEnum =
  (typeof ChangeStatusForbiddenErrorHttpStatusCodeEnum)[keyof typeof ChangeStatusForbiddenErrorHttpStatusCodeEnum]

/**
 * Webhook setting to notify developers for claimed VC
 * @export
 * @interface CisConfigurationWebhookSetting
 */
export interface CisConfigurationWebhookSetting {
  /**
   * flag to enabled or disabled the webhook
   * @type {boolean}
   * @memberof CisConfigurationWebhookSetting
   */
  enabled: boolean
  /**
   *
   * @type {CisConfigurationWebhookSettingEndpoint}
   * @memberof CisConfigurationWebhookSetting
   */
  endpoint?: CisConfigurationWebhookSettingEndpoint
}
/**
 *
 * @export
 * @interface CisConfigurationWebhookSettingEndpoint
 */
export interface CisConfigurationWebhookSettingEndpoint {
  /**
   * url endpoint where notification will be sent with issuanceId after user has claimed the VC related to issuanceId
   * @type {string}
   * @memberof CisConfigurationWebhookSettingEndpoint
   */
  url?: string
}
/**
 * List of claimed credential
 * @export
 * @interface ClaimedCredentialListResponse
 */
export interface ClaimedCredentialListResponse {
  /**
   * list of credentials
   * @type {Array<{ [key: string]: any; }>}
   * @memberof ClaimedCredentialListResponse
   */
  credentials?: Array<{ [key: string]: any }>
  /**
   * for pagination to fetch next set of records
   * @type {string}
   * @memberof ClaimedCredentialListResponse
   */
  lastEvaluatedKey?: string
}
/**
 * Response for getting the claimed VC
 * @export
 * @interface ClaimedCredentialResponse
 */
export interface ClaimedCredentialResponse {
  /**
   * claimed credential for a single issuance
   * @type {{ [key: string]: any; }}
   * @memberof ClaimedCredentialResponse
   * @deprecated
   */
  credential?: { [key: string]: any }
  /**
   * claimed credentials for batch issuances
   * @type {Array<{ [key: string]: any; }>}
   * @memberof ClaimedCredentialResponse
   */
  credentials?: Array<{ [key: string]: any }>
}
/**
 *
 * @export
 * @interface CreateCredentialInput
 */
export interface CreateCredentialInput {
  /**
   * It is a String that identifies a Credential that is being requested to be issued.
   * @type {string}
   * @memberof CreateCredentialInput
   */
  credential_identifier?: string
  /**
   *
   * @type {CredentialProof}
   * @memberof CreateCredentialInput
   */
  proof: CredentialProof
}
/**
 * @type CreateIssuanceConfig400Response
 * @export
 */
export type CreateIssuanceConfig400Response =
  | InvalidIssuerWalletError
  | ProjectCredentialConfigExistError
  | ProjectCredentialConfigNotExistError

/**
 *
 * @export
 * @interface CreateIssuanceConfigInput
 */
export interface CreateIssuanceConfigInput {
  /**
   *
   * @type {string}
   * @memberof CreateIssuanceConfigInput
   */
  name?: string
  /**
   *
   * @type {string}
   * @memberof CreateIssuanceConfigInput
   */
  description?: string
  /**
   * Issuer Wallet id
   * @type {string}
   * @memberof CreateIssuanceConfigInput
   */
  issuerWalletId: string
  /**
   * credential offer duration in second
   * @type {number}
   * @memberof CreateIssuanceConfigInput
   */
  credentialOfferDuration?: number
  /**
   * String identifying the format of this Credential, i.e., ldp_vc. Depending on the format value, the object contains further elements defining the type
   * @type {string}
   * @memberof CreateIssuanceConfigInput
   */
  format?: CreateIssuanceConfigInputFormatEnum
  /**
   *
   * @type {Array<CredentialSupportedObject>}
   * @memberof CreateIssuanceConfigInput
   */
  credentialSupported: Array<CredentialSupportedObject>
  /**
   * Issuer public information wallet may want to show to user during consent confirmation
   * @type {{ [key: string]: any; }}
   * @memberof CreateIssuanceConfigInput
   */
  issuerMetadata?: { [key: string]: any }
  /**
   * List of allowed URIs to be returned to after issuance
   * @type {Array<string>}
   * @memberof CreateIssuanceConfigInput
   */
  returnUris?: Array<string>
  /**
   *
   * @type {CisConfigurationWebhookSetting}
   * @memberof CreateIssuanceConfigInput
   */
  webhook?: CisConfigurationWebhookSetting
}

export const CreateIssuanceConfigInputFormatEnum = {
  LdpVc: 'ldp_vc',
  JwtVcJsonLd: 'jwt_vc_json-ld',
  SdJwtVcJsonLd: 'sd_jwt_vc_json-ld',
} as const

export type CreateIssuanceConfigInputFormatEnum =
  (typeof CreateIssuanceConfigInputFormatEnum)[keyof typeof CreateIssuanceConfigInputFormatEnum]

/**
 *
 * @export
 * @interface CredentialIssuanceIdExistError
 */
export interface CredentialIssuanceIdExistError {
  /**
   *
   * @type {string}
   * @memberof CredentialIssuanceIdExistError
   */
  name: CredentialIssuanceIdExistErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof CredentialIssuanceIdExistError
   */
  message: CredentialIssuanceIdExistErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof CredentialIssuanceIdExistError
   */
  httpStatusCode: CredentialIssuanceIdExistErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof CredentialIssuanceIdExistError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof CredentialIssuanceIdExistError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const CredentialIssuanceIdExistErrorNameEnum = {
  CredentialIssuanceIdExistError: 'CredentialIssuanceIdExistError',
} as const

export type CredentialIssuanceIdExistErrorNameEnum =
  (typeof CredentialIssuanceIdExistErrorNameEnum)[keyof typeof CredentialIssuanceIdExistErrorNameEnum]
export const CredentialIssuanceIdExistErrorMessageEnum = {
  IssuanceIdExistForTheProjectPleaseUseDifferentIssuanceId:
    'issuanceId exist for the project, please use different issuanceId',
} as const

export type CredentialIssuanceIdExistErrorMessageEnum =
  (typeof CredentialIssuanceIdExistErrorMessageEnum)[keyof typeof CredentialIssuanceIdExistErrorMessageEnum]
export const CredentialIssuanceIdExistErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type CredentialIssuanceIdExistErrorHttpStatusCodeEnum =
  (typeof CredentialIssuanceIdExistErrorHttpStatusCodeEnum)[keyof typeof CredentialIssuanceIdExistErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface CredentialOfferClaimedError
 */
export interface CredentialOfferClaimedError {
  /**
   *
   * @type {string}
   * @memberof CredentialOfferClaimedError
   */
  name: CredentialOfferClaimedErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof CredentialOfferClaimedError
   */
  message: CredentialOfferClaimedErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof CredentialOfferClaimedError
   */
  httpStatusCode: CredentialOfferClaimedErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof CredentialOfferClaimedError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof CredentialOfferClaimedError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const CredentialOfferClaimedErrorNameEnum = {
  CredentialOfferClaimedError: 'CredentialOfferClaimedError',
} as const

export type CredentialOfferClaimedErrorNameEnum =
  (typeof CredentialOfferClaimedErrorNameEnum)[keyof typeof CredentialOfferClaimedErrorNameEnum]
export const CredentialOfferClaimedErrorMessageEnum = {
  CredentialOfferIsAlreadyClaimed: 'Credential offer is already claimed',
} as const

export type CredentialOfferClaimedErrorMessageEnum =
  (typeof CredentialOfferClaimedErrorMessageEnum)[keyof typeof CredentialOfferClaimedErrorMessageEnum]
export const CredentialOfferClaimedErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type CredentialOfferClaimedErrorHttpStatusCodeEnum =
  (typeof CredentialOfferClaimedErrorHttpStatusCodeEnum)[keyof typeof CredentialOfferClaimedErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface CredentialOfferExpiredError
 */
export interface CredentialOfferExpiredError {
  /**
   *
   * @type {string}
   * @memberof CredentialOfferExpiredError
   */
  name: CredentialOfferExpiredErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof CredentialOfferExpiredError
   */
  message: CredentialOfferExpiredErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof CredentialOfferExpiredError
   */
  httpStatusCode: CredentialOfferExpiredErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof CredentialOfferExpiredError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof CredentialOfferExpiredError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const CredentialOfferExpiredErrorNameEnum = {
  CredentialOfferExpiredError: 'CredentialOfferExpiredError',
} as const

export type CredentialOfferExpiredErrorNameEnum =
  (typeof CredentialOfferExpiredErrorNameEnum)[keyof typeof CredentialOfferExpiredErrorNameEnum]
export const CredentialOfferExpiredErrorMessageEnum = {
  CredentialOfferIsExpired: 'Credential offer is expired',
} as const

export type CredentialOfferExpiredErrorMessageEnum =
  (typeof CredentialOfferExpiredErrorMessageEnum)[keyof typeof CredentialOfferExpiredErrorMessageEnum]
export const CredentialOfferExpiredErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type CredentialOfferExpiredErrorHttpStatusCodeEnum =
  (typeof CredentialOfferExpiredErrorHttpStatusCodeEnum)[keyof typeof CredentialOfferExpiredErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface CredentialOfferResponse
 */
export interface CredentialOfferResponse {
  /**
   * The URL of the Credential Issuer
   * @type {string}
   * @memberof CredentialOfferResponse
   */
  credential_issuer: string
  /**
   * Array of unique strings that each identify one of the keys in the name/value pairs stored in the credentialSupported
   * @type {Array<string>}
   * @memberof CredentialOfferResponse
   */
  credential_configuration_ids: Array<string>
  /**
   *
   * @type {CredentialOfferResponseGrants}
   * @memberof CredentialOfferResponse
   */
  grants: CredentialOfferResponseGrants
}
/**
 * Object indicating to the Wallet the Grant Types the Credential Issuer\'s Authorization Server is prepared to process for this Credential Offer.
 * @export
 * @interface CredentialOfferResponseGrants
 */
export interface CredentialOfferResponseGrants {
  /**
   *
   * @type {CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode}
   * @memberof CredentialOfferResponseGrants
   */
  'urn:ietf:params:oauth:grant-type:pre-authorized_code': CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode
}
/**
 * Grant type for `pre-authorized_code` flow
 * @export
 * @interface CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode
 */
export interface CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode {
  /**
   * pre authorized code to be exchanged with jwt token
   * @type {string}
   * @memberof CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode
   */
  'pre-authorized_code': string
  /**
   *
   * @type {CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode}
   * @memberof CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode
   */
  tx_code?: CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode
}
/**
 * Object specifying whether the Authorization Server expects presentation of a Transaction Code by the End-User along with the Token Request in a Pre-Authorized Code Flow
 * @export
 * @interface CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode
 */
export interface CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode {
  /**
   * Integer specifying the length of the Transaction Code
   * @type {number}
   * @memberof CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode
   */
  length?: number
  /**
   * String specifying the input character set. Possible values are numeric (only digits) and text (any characters).
   * @type {string}
   * @memberof CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode
   */
  input_mode?: string
  /**
   * String containing guidance for the Holder of the Wallet on how to obtain the Transaction Code
   * @type {string}
   * @memberof CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode
   */
  description?: string
}
/**
 * Object containing the proof of possession of the cryptographic key material the issued Credential would be bound to.
 * @export
 * @interface CredentialProof
 */
export interface CredentialProof {
  /**
   * String denoting the key proof type.
   * @type {string}
   * @memberof CredentialProof
   */
  proof_type: CredentialProofProofTypeEnum
  /**
   *
   * @type {string}
   * @memberof CredentialProof
   */
  jwt: string
}

export const CredentialProofProofTypeEnum = {
  Jwt: 'jwt',
} as const

export type CredentialProofProofTypeEnum =
  (typeof CredentialProofProofTypeEnum)[keyof typeof CredentialProofProofTypeEnum]

/**
 * @type CredentialResponse
 * @export
 */
export type CredentialResponse =
  | CredentialResponseDeferred
  | CredentialResponseImmediate

/**
 *
 * @export
 * @interface CredentialResponseDeferred
 */
export interface CredentialResponseDeferred {
  /**
   * String identifying a Deferred Issuance transaction. This claim is contained in the response if the Credential Issuer was unable to immediately issue the Credential.
   * @type {string}
   * @memberof CredentialResponseDeferred
   */
  transaction_id: string
  /**
   * String containing a nonce to be used when creating a proof of possession of the key proof
   * @type {string}
   * @memberof CredentialResponseDeferred
   */
  c_nonce: string
  /**
   * Lifetime in seconds of the c_nonce
   * @type {number}
   * @memberof CredentialResponseDeferred
   */
  c_nonce_expires_in: number
}
/**
 *
 * @export
 * @interface CredentialResponseImmediate
 */
export interface CredentialResponseImmediate {
  /**
   *
   * @type {CredentialResponseImmediateCredential}
   * @memberof CredentialResponseImmediate
   */
  credential: CredentialResponseImmediateCredential
  /**
   * String containing a nonce to be used when creating a proof of possession of the key proof
   * @type {string}
   * @memberof CredentialResponseImmediate
   */
  c_nonce: string
  /**
   *
   * @type {CredentialResponseImmediateCNonceExpiresIn}
   * @memberof CredentialResponseImmediate
   */
  c_nonce_expires_in: CredentialResponseImmediateCNonceExpiresIn
}
/**
 * @type CredentialResponseImmediateCNonceExpiresIn
 * @export
 */
export type CredentialResponseImmediateCNonceExpiresIn = number | string

/**
 * @type CredentialResponseImmediateCredential
 * @export
 */
export type CredentialResponseImmediateCredential =
  | string
  | { [key: string]: any }

/**
 *
 * @export
 * @interface CredentialSubjectNotValidError
 */
export interface CredentialSubjectNotValidError {
  /**
   *
   * @type {string}
   * @memberof CredentialSubjectNotValidError
   */
  name: CredentialSubjectNotValidErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof CredentialSubjectNotValidError
   */
  message: CredentialSubjectNotValidErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof CredentialSubjectNotValidError
   */
  httpStatusCode: CredentialSubjectNotValidErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof CredentialSubjectNotValidError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof CredentialSubjectNotValidError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const CredentialSubjectNotValidErrorNameEnum = {
  CredentialSubjectNotValidError: 'CredentialSubjectNotValidError',
} as const

export type CredentialSubjectNotValidErrorNameEnum =
  (typeof CredentialSubjectNotValidErrorNameEnum)[keyof typeof CredentialSubjectNotValidErrorNameEnum]
export const CredentialSubjectNotValidErrorMessageEnum = {
  CredentialSubjectIsNotAccordingToTheVcSchema:
    'Credential subject is not according to the vc schema',
} as const

export type CredentialSubjectNotValidErrorMessageEnum =
  (typeof CredentialSubjectNotValidErrorMessageEnum)[keyof typeof CredentialSubjectNotValidErrorMessageEnum]
export const CredentialSubjectNotValidErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type CredentialSubjectNotValidErrorHttpStatusCodeEnum =
  (typeof CredentialSubjectNotValidErrorHttpStatusCodeEnum)[keyof typeof CredentialSubjectNotValidErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface CredentialSupportedObject
 */
export interface CredentialSupportedObject {
  /**
   * It is a String that identifies a Credential that is being requested to be issued.
   * @type {string}
   * @memberof CredentialSupportedObject
   */
  credentialTypeId: string
  /**
   * credential jsonLdContextUrl
   * @type {string}
   * @memberof CredentialSupportedObject
   */
  jsonSchemaUrl: string
  /**
   * credential jsonSchemaUrl
   * @type {string}
   * @memberof CredentialSupportedObject
   */
  jsonLdContextUrl: string
  /**
   *
   * @type {SupportedCredentialMetadata}
   * @memberof CredentialSupportedObject
   */
  metadata?: SupportedCredentialMetadata
}
/**
 *
 * @export
 * @interface FlowData
 */
export interface FlowData {
  /**
   * [GEN] ISO 8601 string of the creation date/time the entity
   * @type {string}
   * @memberof FlowData
   */
  createdAt: string
  /**
   * [GEN] ISO 8601 string of the modification date/time the entity
   * @type {string}
   * @memberof FlowData
   */
  modifiedAt: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  id: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  projectId?: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  flowId: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  credentialTypeId: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  jsonLdContextUrl: string
  /**
   *
   * @type {string}
   * @memberof FlowData
   */
  jsonSchemaUrl: string
  /**
   * Id of configuration, used to issue VC.
   * @type {string}
   * @memberof FlowData
   */
  configurationId?: string
  /**
   * when credential was issued to the holder (holder invoked generateCredentials endpoint)
   * @type {string}
   * @memberof FlowData
   */
  issuedAt?: string
  /**
   * Id of wallet, used to issue VC.
   * @type {string}
   * @memberof FlowData
   */
  walletId?: string
  /**
   * Id of configuration with which VC was issued. To use as an index, it is grouped together with projectId, as \"{projectIdConfigurationId}#{configurationId}\"
   * @type {string}
   * @memberof FlowData
   */
  projectIdConfigurationId?: string
  /**
   * Id of wallet which issued VC. To use as an index, it is grouped together with projectId, as \"{projectIdConfigurationId}#{walletId}\"
   * @type {string}
   * @memberof FlowData
   */
  projectIdConfigurationIdWalletId?: string
  /**
   * VC.type value. To use as an index, it is grouped together with projectId, as \"{projectIdConfigurationId}#{credentialType}\"
   * @type {string}
   * @memberof FlowData
   */
  projectIdConfigurationIdCredentialType?: string
  /**
   *
   * @type {Array<FlowDataStatusListsDetailsInner>}
   * @memberof FlowData
   */
  statusListsDetails?: Array<FlowDataStatusListsDetailsInner>
}
/**
 *
 * @export
 * @interface FlowDataStatusListsDetailsInner
 */
export interface FlowDataStatusListsDetailsInner {
  /**
   * Purpose of status list to which credential is added
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  statusListPurpose: FlowDataStatusListsDetailsInnerStatusListPurposeEnum
  /**
   * id of status list
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  statusListId: string
  /**
   * as usual it is a number, but all standards use a string
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  statusListIndex: string
  /**
   *
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  standard: FlowDataStatusListsDetailsInnerStandardEnum
  /**
   * indicates status is true or not. Default false.
   * @type {boolean}
   * @memberof FlowDataStatusListsDetailsInner
   */
  isActive: boolean
  /**
   * text reasoning why the status is true (if true). Optional.
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  statusActivationReason?: string
  /**
   * ISO 8601 string of the modification date/time the status. Optional.
   * @type {string}
   * @memberof FlowDataStatusListsDetailsInner
   */
  statusActivatedAt?: string
}

export const FlowDataStatusListsDetailsInnerStatusListPurposeEnum = {
  Revoked: 'REVOKED',
} as const

export type FlowDataStatusListsDetailsInnerStatusListPurposeEnum =
  (typeof FlowDataStatusListsDetailsInnerStatusListPurposeEnum)[keyof typeof FlowDataStatusListsDetailsInnerStatusListPurposeEnum]
export const FlowDataStatusListsDetailsInnerStandardEnum = {
  RevocationList2020: 'RevocationList2020',
} as const

export type FlowDataStatusListsDetailsInnerStandardEnum =
  (typeof FlowDataStatusListsDetailsInnerStandardEnum)[keyof typeof FlowDataStatusListsDetailsInnerStandardEnum]

/**
 * @type GenerateCredentials400Response
 * @export
 */
export type GenerateCredentials400Response =
  | InvalidCredentialRequestError
  | InvalidProofError

/**
 * @type GetCredentialOffer400Response
 * @export
 */
export type GetCredentialOffer400Response =
  | CredentialOfferClaimedError
  | CredentialOfferExpiredError
  | InvalidParameterError
  | ProjectCredentialConfigNotExistError
  | VcClaimedError

/**
 *
 * @export
 * @interface InvalidCredentialRequestError
 */
export interface InvalidCredentialRequestError {
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialRequestError
   */
  name: InvalidCredentialRequestErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialRequestError
   */
  message: InvalidCredentialRequestErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidCredentialRequestError
   */
  httpStatusCode: InvalidCredentialRequestErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialRequestError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidCredentialRequestError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidCredentialRequestErrorNameEnum = {
  InvalidCredentialRequestError: 'InvalidCredentialRequestError',
} as const

export type InvalidCredentialRequestErrorNameEnum =
  (typeof InvalidCredentialRequestErrorNameEnum)[keyof typeof InvalidCredentialRequestErrorNameEnum]
export const InvalidCredentialRequestErrorMessageEnum = {
  CredentialRequestIsInvalid: 'Credential Request is invalid',
} as const

export type InvalidCredentialRequestErrorMessageEnum =
  (typeof InvalidCredentialRequestErrorMessageEnum)[keyof typeof InvalidCredentialRequestErrorMessageEnum]
export const InvalidCredentialRequestErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type InvalidCredentialRequestErrorHttpStatusCodeEnum =
  (typeof InvalidCredentialRequestErrorHttpStatusCodeEnum)[keyof typeof InvalidCredentialRequestErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface InvalidCredentialTypeError
 */
export interface InvalidCredentialTypeError {
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialTypeError
   */
  name: InvalidCredentialTypeErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialTypeError
   */
  message: InvalidCredentialTypeErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidCredentialTypeError
   */
  httpStatusCode: InvalidCredentialTypeErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidCredentialTypeError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidCredentialTypeError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidCredentialTypeErrorNameEnum = {
  InvalidCredentialTypeError: 'InvalidCredentialTypeError',
} as const

export type InvalidCredentialTypeErrorNameEnum =
  (typeof InvalidCredentialTypeErrorNameEnum)[keyof typeof InvalidCredentialTypeErrorNameEnum]
export const InvalidCredentialTypeErrorMessageEnum = {
  TheRequestedCredentialTypeIsNotSupported:
    'The requested credential type is not supported',
} as const

export type InvalidCredentialTypeErrorMessageEnum =
  (typeof InvalidCredentialTypeErrorMessageEnum)[keyof typeof InvalidCredentialTypeErrorMessageEnum]
export const InvalidCredentialTypeErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type InvalidCredentialTypeErrorHttpStatusCodeEnum =
  (typeof InvalidCredentialTypeErrorHttpStatusCodeEnum)[keyof typeof InvalidCredentialTypeErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface InvalidIssuerWalletError
 */
export interface InvalidIssuerWalletError {
  /**
   *
   * @type {string}
   * @memberof InvalidIssuerWalletError
   */
  name: InvalidIssuerWalletErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidIssuerWalletError
   */
  message: InvalidIssuerWalletErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidIssuerWalletError
   */
  httpStatusCode: InvalidIssuerWalletErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidIssuerWalletError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidIssuerWalletError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidIssuerWalletErrorNameEnum = {
  InvalidIssuerWalletError: 'InvalidIssuerWalletError',
} as const

export type InvalidIssuerWalletErrorNameEnum =
  (typeof InvalidIssuerWalletErrorNameEnum)[keyof typeof InvalidIssuerWalletErrorNameEnum]
export const InvalidIssuerWalletErrorMessageEnum = {
  IssuerWalletIdIsInvalid: 'issuer wallet id is invalid',
} as const

export type InvalidIssuerWalletErrorMessageEnum =
  (typeof InvalidIssuerWalletErrorMessageEnum)[keyof typeof InvalidIssuerWalletErrorMessageEnum]
export const InvalidIssuerWalletErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type InvalidIssuerWalletErrorHttpStatusCodeEnum =
  (typeof InvalidIssuerWalletErrorHttpStatusCodeEnum)[keyof typeof InvalidIssuerWalletErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface InvalidJwtTokenError
 */
export interface InvalidJwtTokenError {
  /**
   *
   * @type {string}
   * @memberof InvalidJwtTokenError
   */
  name: InvalidJwtTokenErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidJwtTokenError
   */
  message: InvalidJwtTokenErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidJwtTokenError
   */
  httpStatusCode: InvalidJwtTokenErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidJwtTokenError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidJwtTokenError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidJwtTokenErrorNameEnum = {
  InvalidJwtTokenError: 'InvalidJwtTokenError',
} as const

export type InvalidJwtTokenErrorNameEnum =
  (typeof InvalidJwtTokenErrorNameEnum)[keyof typeof InvalidJwtTokenErrorNameEnum]
export const InvalidJwtTokenErrorMessageEnum = {
  JwtTokenIsInvalid: 'JWT token is invalid',
} as const

export type InvalidJwtTokenErrorMessageEnum =
  (typeof InvalidJwtTokenErrorMessageEnum)[keyof typeof InvalidJwtTokenErrorMessageEnum]
export const InvalidJwtTokenErrorHttpStatusCodeEnum = {
  NUMBER_401: 401,
} as const

export type InvalidJwtTokenErrorHttpStatusCodeEnum =
  (typeof InvalidJwtTokenErrorHttpStatusCodeEnum)[keyof typeof InvalidJwtTokenErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface InvalidParameterError
 */
export interface InvalidParameterError {
  /**
   *
   * @type {string}
   * @memberof InvalidParameterError
   */
  name: InvalidParameterErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidParameterError
   */
  message: InvalidParameterErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidParameterError
   */
  httpStatusCode: InvalidParameterErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidParameterError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidParameterError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidParameterErrorNameEnum = {
  InvalidParameterError: 'InvalidParameterError',
} as const

export type InvalidParameterErrorNameEnum =
  (typeof InvalidParameterErrorNameEnum)[keyof typeof InvalidParameterErrorNameEnum]
export const InvalidParameterErrorMessageEnum = {
  InvalidParameterParam: 'Invalid parameter: ${param}.',
} as const

export type InvalidParameterErrorMessageEnum =
  (typeof InvalidParameterErrorMessageEnum)[keyof typeof InvalidParameterErrorMessageEnum]
export const InvalidParameterErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type InvalidParameterErrorHttpStatusCodeEnum =
  (typeof InvalidParameterErrorHttpStatusCodeEnum)[keyof typeof InvalidParameterErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface InvalidProofError
 */
export interface InvalidProofError {
  /**
   *
   * @type {string}
   * @memberof InvalidProofError
   */
  name: InvalidProofErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof InvalidProofError
   */
  message: InvalidProofErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof InvalidProofError
   */
  httpStatusCode: InvalidProofErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof InvalidProofError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof InvalidProofError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const InvalidProofErrorNameEnum = {
  InvalidProofError: 'InvalidProofError',
} as const

export type InvalidProofErrorNameEnum =
  (typeof InvalidProofErrorNameEnum)[keyof typeof InvalidProofErrorNameEnum]
export const InvalidProofErrorMessageEnum = {
  TheProofInTheCredentialRequestIsInvalid:
    'The proof in the Credential Request is invalid',
} as const

export type InvalidProofErrorMessageEnum =
  (typeof InvalidProofErrorMessageEnum)[keyof typeof InvalidProofErrorMessageEnum]
export const InvalidProofErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type InvalidProofErrorHttpStatusCodeEnum =
  (typeof InvalidProofErrorHttpStatusCodeEnum)[keyof typeof InvalidProofErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface IssuanceConfigDto
 */
export interface IssuanceConfigDto {
  /**
   *
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  id?: string
  /**
   *
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  name?: string
  /**
   *
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  description?: string
  /**
   * Issuer DID
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  issuerDid?: string
  /**
   * Issuer Wallet id
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  issuerWalletId?: string
  /**
   * credential offer duration in second
   * @type {number}
   * @memberof IssuanceConfigDto
   */
  credentialOfferDuration?: number
  /**
   * c_nonce duration in second
   * @type {number}
   * @memberof IssuanceConfigDto
   */
  cNonceDuration?: number
  /**
   * String identifying the format of this Credential, i.e., jwt_vc_json-ld or ldp_vc. Depending on the format value, the object contains further elements defining the type
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  format?: IssuanceConfigDtoFormatEnum
  /**
   * Issuer URI
   * @type {string}
   * @memberof IssuanceConfigDto
   */
  issuerUri?: string
  /**
   *
   * @type {Array<CredentialSupportedObject>}
   * @memberof IssuanceConfigDto
   */
  credentialSupported?: Array<CredentialSupportedObject>
  /**
   * Issuer public information wallet may want to show to user during consent confirmation
   * @type {{ [key: string]: any; }}
   * @memberof IssuanceConfigDto
   */
  issuerMetadata?: { [key: string]: any }
  /**
   *
   * @type {number}
   * @memberof IssuanceConfigDto
   */
  version?: number
  /**
   * List of allowed URIs to be returned to after issuance
   * @type {Array<string>}
   * @memberof IssuanceConfigDto
   */
  returnUris?: Array<string>
  /**
   *
   * @type {CisConfigurationWebhookSetting}
   * @memberof IssuanceConfigDto
   */
  webhook?: CisConfigurationWebhookSetting
}

export const IssuanceConfigDtoFormatEnum = {
  LdpVc: 'ldp_vc',
  JwtVcJsonLd: 'jwt_vc_json-ld',
  SdJwtVcJsonLd: 'sd_jwt_vc_json-ld',
} as const

export type IssuanceConfigDtoFormatEnum =
  (typeof IssuanceConfigDtoFormatEnum)[keyof typeof IssuanceConfigDtoFormatEnum]

/**
 *
 * @export
 * @interface IssuanceConfigListResponse
 */
export interface IssuanceConfigListResponse {
  /**
   *
   * @type {Array<IssuanceConfigMiniDto>}
   * @memberof IssuanceConfigListResponse
   */
  configurations: Array<IssuanceConfigMiniDto>
}
/**
 *
 * @export
 * @interface IssuanceConfigMiniDto
 */
export interface IssuanceConfigMiniDto {
  /**
   *
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  id: string
  /**
   *
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  name?: string
  /**
   * Issuer DID
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  issuerDid?: string
  /**
   * Issuer Wallet id
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  issuerWalletId?: string
  /**
   * credential offer duration in second
   * @type {number}
   * @memberof IssuanceConfigMiniDto
   */
  credentialOfferDuration?: number
  /**
   * c_nonce duration in second
   * @type {number}
   * @memberof IssuanceConfigMiniDto
   */
  cNonceDuration?: number
  /**
   * String identifying the format of this Credential, i.e., jwt_vc_json-ld or ldp_vc. Depending on the format value, the object contains further elements defining the type
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  format?: IssuanceConfigMiniDtoFormatEnum
  /**
   * Issuer URI
   * @type {string}
   * @memberof IssuanceConfigMiniDto
   */
  issuerUri?: string
  /**
   * Issuer public information wallet may want to show to user during consent confirmation
   * @type {{ [key: string]: any; }}
   * @memberof IssuanceConfigMiniDto
   */
  issuerMetadata?: { [key: string]: any }
  /**
   *
   * @type {number}
   * @memberof IssuanceConfigMiniDto
   */
  version?: number
}

export const IssuanceConfigMiniDtoFormatEnum = {
  LdpVc: 'ldp_vc',
  JwtVcJsonLd: 'jwt_vc_json-ld',
  SdJwtVcJsonLd: 'sd_jwt_vc_json-ld',
} as const

export type IssuanceConfigMiniDtoFormatEnum =
  (typeof IssuanceConfigMiniDtoFormatEnum)[keyof typeof IssuanceConfigMiniDtoFormatEnum]

/**
 *
 * @export
 * @interface IssuanceStateResponse
 */
export interface IssuanceStateResponse {
  /**
   * Website\'s internal identifier. Website may use to get info about the status of issuance flow. If it is not provided, CIS will generate one.
   * @type {string}
   * @memberof IssuanceStateResponse
   */
  issuanceId: string
  /**
   * String describing the status of the issuance
   * @type {string}
   * @memberof IssuanceStateResponse
   */
  status: IssuanceStateResponseStatusEnum
}

export const IssuanceStateResponseStatusEnum = {
  Init: 'INIT',
  OfferDelivered: 'OFFER_DELIVERED',
  VcClaimed: 'VC_CLAIMED',
  Timeout: 'TIMEOUT',
} as const

export type IssuanceStateResponseStatusEnum =
  (typeof IssuanceStateResponseStatusEnum)[keyof typeof IssuanceStateResponseStatusEnum]

/**
 * list of issuance data records
 * @export
 * @interface ListIssuanceRecordResponse
 */
export interface ListIssuanceRecordResponse {
  /**
   *
   * @type {Array<FlowData>}
   * @memberof ListIssuanceRecordResponse
   */
  flowData?: Array<FlowData>
  /**
   *
   * @type {string}
   * @memberof ListIssuanceRecordResponse
   */
  lastEvaluatedKey?: string
}
/**
 *
 * @export
 * @interface ListIssuanceResponse
 */
export interface ListIssuanceResponse {
  /**
   * The list of all issuances for the Project
   * @type {Array<ListIssuanceResponseIssuancesInner>}
   * @memberof ListIssuanceResponse
   */
  issuances: Array<ListIssuanceResponseIssuancesInner>
}
/**
 *
 * @export
 * @interface ListIssuanceResponseIssuancesInner
 */
export interface ListIssuanceResponseIssuancesInner {
  /**
   * issuance id
   * @type {string}
   * @memberof ListIssuanceResponseIssuancesInner
   */
  id: string
}
/**
 *
 * @export
 * @interface MissingHolderDidError
 */
export interface MissingHolderDidError {
  /**
   *
   * @type {string}
   * @memberof MissingHolderDidError
   */
  name: MissingHolderDidErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof MissingHolderDidError
   */
  message: MissingHolderDidErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof MissingHolderDidError
   */
  httpStatusCode: MissingHolderDidErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof MissingHolderDidError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof MissingHolderDidError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const MissingHolderDidErrorNameEnum = {
  MissingHolderDidError: 'MissingHolderDidError',
} as const

export type MissingHolderDidErrorNameEnum =
  (typeof MissingHolderDidErrorNameEnum)[keyof typeof MissingHolderDidErrorNameEnum]
export const MissingHolderDidErrorMessageEnum = {
  HolderDidIsRequiredInThisClaimMode: 'holderDID is required in this claimMode',
} as const

export type MissingHolderDidErrorMessageEnum =
  (typeof MissingHolderDidErrorMessageEnum)[keyof typeof MissingHolderDidErrorMessageEnum]
export const MissingHolderDidErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type MissingHolderDidErrorHttpStatusCodeEnum =
  (typeof MissingHolderDidErrorHttpStatusCodeEnum)[keyof typeof MissingHolderDidErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface NotFoundError
 */
export interface NotFoundError {
  /**
   *
   * @type {string}
   * @memberof NotFoundError
   */
  name: NotFoundErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof NotFoundError
   */
  message: NotFoundErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof NotFoundError
   */
  httpStatusCode: NotFoundErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof NotFoundError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof NotFoundError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const NotFoundErrorNameEnum = {
  NotFoundError: 'NotFoundError',
} as const

export type NotFoundErrorNameEnum =
  (typeof NotFoundErrorNameEnum)[keyof typeof NotFoundErrorNameEnum]
export const NotFoundErrorMessageEnum = {
  NotFoundParam: 'Not found: ${param}.',
} as const

export type NotFoundErrorMessageEnum =
  (typeof NotFoundErrorMessageEnum)[keyof typeof NotFoundErrorMessageEnum]
export const NotFoundErrorHttpStatusCodeEnum = {
  NUMBER_404: 404,
} as const

export type NotFoundErrorHttpStatusCodeEnum =
  (typeof NotFoundErrorHttpStatusCodeEnum)[keyof typeof NotFoundErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface ProjectCredentialConfigExistError
 */
export interface ProjectCredentialConfigExistError {
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigExistError
   */
  name: ProjectCredentialConfigExistErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigExistError
   */
  message: ProjectCredentialConfigExistErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof ProjectCredentialConfigExistError
   */
  httpStatusCode: ProjectCredentialConfigExistErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigExistError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof ProjectCredentialConfigExistError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const ProjectCredentialConfigExistErrorNameEnum = {
  ProjectCredentialConfigExistError: 'ProjectCredentialConfigExistError',
} as const

export type ProjectCredentialConfigExistErrorNameEnum =
  (typeof ProjectCredentialConfigExistErrorNameEnum)[keyof typeof ProjectCredentialConfigExistErrorNameEnum]
export const ProjectCredentialConfigExistErrorMessageEnum = {
  CredentialConfigurationAlreadyExistsForThisProjectAndOnlyOneConfigurationIsAllowedPerProject:
    'Credential configuration already exists for this project and only one configuration is allowed per project',
} as const

export type ProjectCredentialConfigExistErrorMessageEnum =
  (typeof ProjectCredentialConfigExistErrorMessageEnum)[keyof typeof ProjectCredentialConfigExistErrorMessageEnum]
export const ProjectCredentialConfigExistErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type ProjectCredentialConfigExistErrorHttpStatusCodeEnum =
  (typeof ProjectCredentialConfigExistErrorHttpStatusCodeEnum)[keyof typeof ProjectCredentialConfigExistErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface ProjectCredentialConfigNotExistError
 */
export interface ProjectCredentialConfigNotExistError {
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigNotExistError
   */
  name: ProjectCredentialConfigNotExistErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigNotExistError
   */
  message: ProjectCredentialConfigNotExistErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof ProjectCredentialConfigNotExistError
   */
  httpStatusCode: ProjectCredentialConfigNotExistErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof ProjectCredentialConfigNotExistError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof ProjectCredentialConfigNotExistError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const ProjectCredentialConfigNotExistErrorNameEnum = {
  ProjectCredentialConfigNotExistError: 'ProjectCredentialConfigNotExistError',
} as const

export type ProjectCredentialConfigNotExistErrorNameEnum =
  (typeof ProjectCredentialConfigNotExistErrorNameEnum)[keyof typeof ProjectCredentialConfigNotExistErrorNameEnum]
export const ProjectCredentialConfigNotExistErrorMessageEnum = {
  CredentialConfigIsNotAvailableForTheProject:
    'Credential config is not available for the project',
} as const

export type ProjectCredentialConfigNotExistErrorMessageEnum =
  (typeof ProjectCredentialConfigNotExistErrorMessageEnum)[keyof typeof ProjectCredentialConfigNotExistErrorMessageEnum]
export const ProjectCredentialConfigNotExistErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type ProjectCredentialConfigNotExistErrorHttpStatusCodeEnum =
  (typeof ProjectCredentialConfigNotExistErrorHttpStatusCodeEnum)[keyof typeof ProjectCredentialConfigNotExistErrorHttpStatusCodeEnum]

/**
 * @type StartIssuance400Response
 * @export
 */
export type StartIssuance400Response =
  | CredentialIssuanceIdExistError
  | CredentialSubjectNotValidError
  | InvalidCredentialTypeError
  | InvalidParameterError
  | MissingHolderDidError
  | ProjectCredentialConfigNotExistError

/**
 *
 * @export
 * @interface StartIssuanceInput
 */
export interface StartIssuanceInput {
  /**
   * In TX_CODE claim mode, additional transaction code will be generated and the Authorization Server expects presentation of the transaction Code by the end-user. If FIXED_HOLDER claim mode is defined, holderDid must be present and service will not generate additional transaction code (NORMAL claimMode is deprecated).
   * @type {string}
   * @memberof StartIssuanceInput
   */
  claimMode?: StartIssuanceInputClaimModeEnum
  /**
   * Holder DID
   * @type {string}
   * @memberof StartIssuanceInput
   */
  holderDid?: string
  /**
   * Website\'s internal identifier. Website may use to get info about the status of issuance flow. If it is not provided, CIS will generate one.
   * @type {string}
   * @memberof StartIssuanceInput
   */
  issuanceId?: string
  /**
   *
   * @type {Array<StartIssuanceInputDataInner>}
   * @memberof StartIssuanceInput
   */
  data: Array<StartIssuanceInputDataInner>
}

export const StartIssuanceInputClaimModeEnum = {
  Normal: 'NORMAL',
  TxCode: 'TX_CODE',
  FixedHolder: 'FIXED_HOLDER',
} as const

export type StartIssuanceInputClaimModeEnum =
  (typeof StartIssuanceInputClaimModeEnum)[keyof typeof StartIssuanceInputClaimModeEnum]

/**
 * Data to be included in issued credential
 * @export
 * @interface StartIssuanceInputDataInner
 */
export interface StartIssuanceInputDataInner {
  /**
   * It is a String that identifies a Credential that is being requested to be issued.
   * @type {string}
   * @memberof StartIssuanceInputDataInner
   */
  credentialTypeId: string
  /**
   * Object of data to be included in the issued credential ,should  match the credential type
   * @type {{ [key: string]: any; }}
   * @memberof StartIssuanceInputDataInner
   */
  credentialData: { [key: string]: any }
  /**
   * Types of status lists to which the credential should be added once issued. If not provided or empty, the credential is not added to any of the status lists.
   * @type {Array<StartIssuanceInputDataInnerStatusListDetailsInner>}
   * @memberof StartIssuanceInputDataInner
   */
  statusListDetails?: Array<StartIssuanceInputDataInnerStatusListDetailsInner>
  /**
   *
   * @type {StartIssuanceInputDataInnerMetaData}
   * @memberof StartIssuanceInputDataInner
   */
  metaData?: StartIssuanceInputDataInnerMetaData
}
/**
 * Object of metadata to be included in the additionalProperties related to vc
 * @export
 * @interface StartIssuanceInputDataInnerMetaData
 */
export interface StartIssuanceInputDataInnerMetaData {
  /**
   * Date and time when the credential will expire
   * @type {string}
   * @memberof StartIssuanceInputDataInnerMetaData
   */
  expirationDate: string
}
/**
 *
 * @export
 * @interface StartIssuanceInputDataInnerStatusListDetailsInner
 */
export interface StartIssuanceInputDataInnerStatusListDetailsInner {
  /**
   *
   * @type {string}
   * @memberof StartIssuanceInputDataInnerStatusListDetailsInner
   */
  purpose: StartIssuanceInputDataInnerStatusListDetailsInnerPurposeEnum
  /**
   *
   * @type {string}
   * @memberof StartIssuanceInputDataInnerStatusListDetailsInner
   */
  standard: StartIssuanceInputDataInnerStatusListDetailsInnerStandardEnum
}

export const StartIssuanceInputDataInnerStatusListDetailsInnerPurposeEnum = {
  Revocable: 'REVOCABLE',
} as const

export type StartIssuanceInputDataInnerStatusListDetailsInnerPurposeEnum =
  (typeof StartIssuanceInputDataInnerStatusListDetailsInnerPurposeEnum)[keyof typeof StartIssuanceInputDataInnerStatusListDetailsInnerPurposeEnum]
export const StartIssuanceInputDataInnerStatusListDetailsInnerStandardEnum = {
  RevocationList2020: 'RevocationList2020',
} as const

export type StartIssuanceInputDataInnerStatusListDetailsInnerStandardEnum =
  (typeof StartIssuanceInputDataInnerStatusListDetailsInnerStandardEnum)[keyof typeof StartIssuanceInputDataInnerStatusListDetailsInnerStandardEnum]

/**
 *
 * @export
 * @interface StartIssuanceResponse
 */
export interface StartIssuanceResponse {
  /**
   * URL where wallet can view offer details
   * @type {string}
   * @memberof StartIssuanceResponse
   */
  credentialOfferUri: string
  /**
   * One time transaction code generated by CIS
   * @type {string}
   * @memberof StartIssuanceResponse
   */
  txCode?: string
  /**
   * Website\'s internal identifier. Website may use to get info about the status of issuance flow. If it is not provided, CIS will generate one.
   * @type {string}
   * @memberof StartIssuanceResponse
   */
  issuanceId: string
  /**
   * Expire time in seconds
   * @type {number}
   * @memberof StartIssuanceResponse
   */
  expiresIn: number
}
/**
 *
 * @export
 * @interface SupportedCredentialMetadata
 */
export interface SupportedCredentialMetadata {
  /**
   *
   * @type {Array<SupportedCredentialMetadataDisplayInner>}
   * @memberof SupportedCredentialMetadata
   */
  display?: Array<SupportedCredentialMetadataDisplayInner>
}
/**
 *
 * @export
 * @interface SupportedCredentialMetadataDisplayInner
 */
export interface SupportedCredentialMetadataDisplayInner {
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataDisplayInner
   */
  name: string
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataDisplayInner
   */
  locale?: string
  /**
   *
   * @type {SupportedCredentialMetadataItemLogo}
   * @memberof SupportedCredentialMetadataDisplayInner
   */
  logo?: SupportedCredentialMetadataItemLogo
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataDisplayInner
   */
  backgroundColor?: string
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataDisplayInner
   */
  textColor?: string
}
/**
 *
 * @export
 * @interface SupportedCredentialMetadataItemLogo
 */
export interface SupportedCredentialMetadataItemLogo {
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataItemLogo
   */
  url: string
  /**
   *
   * @type {string}
   * @memberof SupportedCredentialMetadataItemLogo
   */
  altText?: string
}
/**
 *
 * @export
 * @interface UpdateIssuanceConfigInput
 */
export interface UpdateIssuanceConfigInput {
  /**
   *
   * @type {string}
   * @memberof UpdateIssuanceConfigInput
   */
  name?: string
  /**
   *
   * @type {string}
   * @memberof UpdateIssuanceConfigInput
   */
  description?: string
  /**
   * Issuer Wallet id
   * @type {string}
   * @memberof UpdateIssuanceConfigInput
   */
  issuerWalletId?: string
  /**
   * credential offer duration in second
   * @type {number}
   * @memberof UpdateIssuanceConfigInput
   */
  credentialOfferDuration?: number
  /**
   * String identifying the format of this Credential, i.e., ldp_vc. Depending on the format value, the object contains further elements defining the type
   * @type {string}
   * @memberof UpdateIssuanceConfigInput
   */
  format?: UpdateIssuanceConfigInputFormatEnum
  /**
   * Issuer URI
   * @type {string}
   * @memberof UpdateIssuanceConfigInput
   */
  issuerUri?: string
  /**
   *
   * @type {Array<CredentialSupportedObject>}
   * @memberof UpdateIssuanceConfigInput
   */
  credentialSupported?: Array<CredentialSupportedObject>
  /**
   * Issuer public information wallet may want to show to user during consent confirmation
   * @type {{ [key: string]: any; }}
   * @memberof UpdateIssuanceConfigInput
   */
  issuerMetadata?: { [key: string]: any }
  /**
   * List of allowed URIs to be returned to after issuance
   * @type {Array<string>}
   * @memberof UpdateIssuanceConfigInput
   */
  returnUris?: Array<string>
  /**
   *
   * @type {CisConfigurationWebhookSetting}
   * @memberof UpdateIssuanceConfigInput
   */
  webhook?: CisConfigurationWebhookSetting
}

export const UpdateIssuanceConfigInputFormatEnum = {
  LdpVc: 'ldp_vc',
  JwtVcJsonLd: 'jwt_vc_json-ld',
  SdJwtVcJsonLd: 'sd_jwt_vc_json-ld',
} as const

export type UpdateIssuanceConfigInputFormatEnum =
  (typeof UpdateIssuanceConfigInputFormatEnum)[keyof typeof UpdateIssuanceConfigInputFormatEnum]

/**
 *
 * @export
 * @interface VcClaimedError
 */
export interface VcClaimedError {
  /**
   *
   * @type {string}
   * @memberof VcClaimedError
   */
  name: VcClaimedErrorNameEnum
  /**
   *
   * @type {string}
   * @memberof VcClaimedError
   */
  message: VcClaimedErrorMessageEnum
  /**
   *
   * @type {number}
   * @memberof VcClaimedError
   */
  httpStatusCode: VcClaimedErrorHttpStatusCodeEnum
  /**
   *
   * @type {string}
   * @memberof VcClaimedError
   */
  traceId: string
  /**
   *
   * @type {Array<ActionForbiddenErrorDetailsInner>}
   * @memberof VcClaimedError
   */
  details?: Array<ActionForbiddenErrorDetailsInner>
}

export const VcClaimedErrorNameEnum = {
  VcClaimedError: 'VcClaimedError',
} as const

export type VcClaimedErrorNameEnum =
  (typeof VcClaimedErrorNameEnum)[keyof typeof VcClaimedErrorNameEnum]
export const VcClaimedErrorMessageEnum = {
  TheRequestedVcHasAlreadyBeenClaimedByTheUser:
    'The requested VC has already been claimed by the user',
} as const

export type VcClaimedErrorMessageEnum =
  (typeof VcClaimedErrorMessageEnum)[keyof typeof VcClaimedErrorMessageEnum]
export const VcClaimedErrorHttpStatusCodeEnum = {
  NUMBER_400: 400,
} as const

export type VcClaimedErrorHttpStatusCodeEnum =
  (typeof VcClaimedErrorHttpStatusCodeEnum)[keyof typeof VcClaimedErrorHttpStatusCodeEnum]

/**
 *
 * @export
 * @interface WellKnownOpenIdCredentialIssuerResponse
 */
export interface WellKnownOpenIdCredentialIssuerResponse {
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  authorization_endpoint?: string
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  credential_endpoint?: string
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  credential_issuer?: string
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  batch_credential_endpoint?: string
  /**
   *
   * @type {Array<WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  credentials_supported?: Array<WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner>
  /**
   *
   * @type {Array<object>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  credential_configurations_supported?: Array<object>
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  deferred_credential_endpoint?: string
  /**
   *
   * @type {Array<string>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  grant_types_supported?: Array<WellKnownOpenIdCredentialIssuerResponseGrantTypesSupportedEnum>
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  jwks_uri?: string
  /**
   *
   * @type {WellKnownOpenIdCredentialIssuerResponseDisplay}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  display?: WellKnownOpenIdCredentialIssuerResponseDisplay
  /**
   *
   * @type {Array<string>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  scopes_supported?: Array<WellKnownOpenIdCredentialIssuerResponseScopesSupportedEnum>
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  token_endpoint?: string
  /**
   *
   * @type {Array<string>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  token_endpoint_auth_methods_supported?: Array<WellKnownOpenIdCredentialIssuerResponseTokenEndpointAuthMethodsSupportedEnum>
  /**
   *
   * @type {Array<string>}
   * @memberof WellKnownOpenIdCredentialIssuerResponse
   */
  return_uris?: Array<string>
}

export const WellKnownOpenIdCredentialIssuerResponseGrantTypesSupportedEnum = {
  AuthorizationCode: 'authorization_code',
  UrnIetfParamsOauthGrantTypePreAuthorizedCode:
    'urn:ietf:params:oauth:grant-type:pre-authorized_code',
} as const

export type WellKnownOpenIdCredentialIssuerResponseGrantTypesSupportedEnum =
  (typeof WellKnownOpenIdCredentialIssuerResponseGrantTypesSupportedEnum)[keyof typeof WellKnownOpenIdCredentialIssuerResponseGrantTypesSupportedEnum]
export const WellKnownOpenIdCredentialIssuerResponseScopesSupportedEnum = {
  Openid: 'openid',
} as const

export type WellKnownOpenIdCredentialIssuerResponseScopesSupportedEnum =
  (typeof WellKnownOpenIdCredentialIssuerResponseScopesSupportedEnum)[keyof typeof WellKnownOpenIdCredentialIssuerResponseScopesSupportedEnum]
export const WellKnownOpenIdCredentialIssuerResponseTokenEndpointAuthMethodsSupportedEnum =
  {
    ClientSecretPost: 'client_secret_post',
    ClientSecretBasic: 'client_secret_basic',
    None: 'none',
  } as const

export type WellKnownOpenIdCredentialIssuerResponseTokenEndpointAuthMethodsSupportedEnum =
  (typeof WellKnownOpenIdCredentialIssuerResponseTokenEndpointAuthMethodsSupportedEnum)[keyof typeof WellKnownOpenIdCredentialIssuerResponseTokenEndpointAuthMethodsSupportedEnum]

/**
 *
 * @export
 * @interface WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner
 */
export interface WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner {
  /**
   * It is a String that identifies a Credential that is being requested to be issued.
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner
   */
  credentialTypeId: string
  /**
   * credential jsonLdContextUrl
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner
   */
  jsonSchemaUrl: string
  /**
   * credential jsonSchemaUrl
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner
   */
  jsonLdContextUrl: string
}
/**
 *
 * @export
 * @interface WellKnownOpenIdCredentialIssuerResponseDisplay
 */
export interface WellKnownOpenIdCredentialIssuerResponseDisplay {
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseDisplay
   */
  name?: string
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseDisplay
   */
  locale?: string
  /**
   *
   * @type {WellKnownOpenIdCredentialIssuerResponseDisplayLogo}
   * @memberof WellKnownOpenIdCredentialIssuerResponseDisplay
   */
  logo?: WellKnownOpenIdCredentialIssuerResponseDisplayLogo
}
/**
 *
 * @export
 * @interface WellKnownOpenIdCredentialIssuerResponseDisplayLogo
 */
export interface WellKnownOpenIdCredentialIssuerResponseDisplayLogo {
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseDisplayLogo
   */
  uri: string
  /**
   *
   * @type {string}
   * @memberof WellKnownOpenIdCredentialIssuerResponseDisplayLogo
   */
  alt_text?: string
}

/**
 * ConfigurationApi - axios parameter creator
 * @export
 */
export const ConfigurationApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     * Create issuance configuration, project have only one configuration
     * @param {CreateIssuanceConfigInput} createIssuanceConfigInput Request body of create configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    createIssuanceConfig: async (
      createIssuanceConfigInput: CreateIssuanceConfigInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'createIssuanceConfigInput' is not null or undefined
      assertParamExists(
        'createIssuanceConfig',
        'createIssuanceConfigInput',
        createIssuanceConfigInput,
      )
      const localVarPath = `/v1/configurations`
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        createIssuanceConfigInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Delete project issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    deleteIssuanceConfigById: async (
      configurationId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'deleteIssuanceConfigById',
        'configurationId',
        configurationId,
      )
      const localVarPath = `/v1/configurations/{configurationId}`.replace(
        `{${'configurationId'}}`,
        encodeURIComponent(String(configurationId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'DELETE',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Get issuance configuration by id
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceConfigById: async (
      configurationId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'getIssuanceConfigById',
        'configurationId',
        configurationId,
      )
      const localVarPath = `/v1/configurations/{configurationId}`.replace(
        `{${'configurationId'}}`,
        encodeURIComponent(String(configurationId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Get issuance configuration for my selected project
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceConfigList: async (
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      const localVarPath = `/v1/configurations`
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Update issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {UpdateIssuanceConfigInput} updateIssuanceConfigInput Request body of update configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    updateIssuanceConfigById: async (
      configurationId: string,
      updateIssuanceConfigInput: UpdateIssuanceConfigInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'updateIssuanceConfigById',
        'configurationId',
        configurationId,
      )
      // verify required parameter 'updateIssuanceConfigInput' is not null or undefined
      assertParamExists(
        'updateIssuanceConfigById',
        'updateIssuanceConfigInput',
        updateIssuanceConfigInput,
      )
      const localVarPath = `/v1/configurations/{configurationId}`.replace(
        `{${'configurationId'}}`,
        encodeURIComponent(String(configurationId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'PUT',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        updateIssuanceConfigInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * ConfigurationApi - functional programming interface
 * @export
 */
export const ConfigurationApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator =
    ConfigurationApiAxiosParamCreator(configuration)
  return {
    /**
     * Create issuance configuration, project have only one configuration
     * @param {CreateIssuanceConfigInput} createIssuanceConfigInput Request body of create configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async createIssuanceConfig(
      createIssuanceConfigInput: CreateIssuanceConfigInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<IssuanceConfigDto>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.createIssuanceConfig(
          createIssuanceConfigInput,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['ConfigurationApi.createIssuanceConfig']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Delete project issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async deleteIssuanceConfigById(
      configurationId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.deleteIssuanceConfigById(
          configurationId,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['ConfigurationApi.deleteIssuanceConfigById']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Get issuance configuration by id
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getIssuanceConfigById(
      configurationId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<IssuanceConfigDto>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getIssuanceConfigById(
          configurationId,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['ConfigurationApi.getIssuanceConfigById']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Get issuance configuration for my selected project
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getIssuanceConfigList(
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<IssuanceConfigListResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getIssuanceConfigList(options)
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['ConfigurationApi.getIssuanceConfigList']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Update issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {UpdateIssuanceConfigInput} updateIssuanceConfigInput Request body of update configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async updateIssuanceConfigById(
      configurationId: string,
      updateIssuanceConfigInput: UpdateIssuanceConfigInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<IssuanceConfigDto>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.updateIssuanceConfigById(
          configurationId,
          updateIssuanceConfigInput,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['ConfigurationApi.updateIssuanceConfigById']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * ConfigurationApi - factory interface
 * @export
 */
export const ConfigurationApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = ConfigurationApiFp(configuration)
  return {
    /**
     * Create issuance configuration, project have only one configuration
     * @param {CreateIssuanceConfigInput} createIssuanceConfigInput Request body of create configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    createIssuanceConfig(
      createIssuanceConfigInput: CreateIssuanceConfigInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<IssuanceConfigDto> {
      return localVarFp
        .createIssuanceConfig(createIssuanceConfigInput, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Delete project issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    deleteIssuanceConfigById(
      configurationId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<void> {
      return localVarFp
        .deleteIssuanceConfigById(configurationId, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Get issuance configuration by id
     * @param {string} configurationId The id of the issuance configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceConfigById(
      configurationId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<IssuanceConfigDto> {
      return localVarFp
        .getIssuanceConfigById(configurationId, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Get issuance configuration for my selected project
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceConfigList(
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<IssuanceConfigListResponse> {
      return localVarFp
        .getIssuanceConfigList(options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Update issuance configuration
     * @param {string} configurationId The id of the issuance configuration
     * @param {UpdateIssuanceConfigInput} updateIssuanceConfigInput Request body of update configuration
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    updateIssuanceConfigById(
      configurationId: string,
      updateIssuanceConfigInput: UpdateIssuanceConfigInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<IssuanceConfigDto> {
      return localVarFp
        .updateIssuanceConfigById(
          configurationId,
          updateIssuanceConfigInput,
          options,
        )
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * ConfigurationApi - object-oriented interface
 * @export
 * @class ConfigurationApi
 * @extends {BaseAPI}
 */
export class ConfigurationApi extends BaseAPI {
  /**
   * Create issuance configuration, project have only one configuration
   * @param {CreateIssuanceConfigInput} createIssuanceConfigInput Request body of create configuration
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof ConfigurationApi
   */
  public createIssuanceConfig(
    createIssuanceConfigInput: CreateIssuanceConfigInput,
    options?: RawAxiosRequestConfig,
  ) {
    return ConfigurationApiFp(this.configuration)
      .createIssuanceConfig(createIssuanceConfigInput, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Delete project issuance configuration
   * @param {string} configurationId The id of the issuance configuration
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof ConfigurationApi
   */
  public deleteIssuanceConfigById(
    configurationId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return ConfigurationApiFp(this.configuration)
      .deleteIssuanceConfigById(configurationId, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Get issuance configuration by id
   * @param {string} configurationId The id of the issuance configuration
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof ConfigurationApi
   */
  public getIssuanceConfigById(
    configurationId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return ConfigurationApiFp(this.configuration)
      .getIssuanceConfigById(configurationId, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Get issuance configuration for my selected project
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof ConfigurationApi
   */
  public getIssuanceConfigList(options?: RawAxiosRequestConfig) {
    return ConfigurationApiFp(this.configuration)
      .getIssuanceConfigList(options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Update issuance configuration
   * @param {string} configurationId The id of the issuance configuration
   * @param {UpdateIssuanceConfigInput} updateIssuanceConfigInput Request body of update configuration
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof ConfigurationApi
   */
  public updateIssuanceConfigById(
    configurationId: string,
    updateIssuanceConfigInput: UpdateIssuanceConfigInput,
    options?: RawAxiosRequestConfig,
  ) {
    return ConfigurationApiFp(this.configuration)
      .updateIssuanceConfigById(
        configurationId,
        updateIssuanceConfigInput,
        options,
      )
      .then((request) => request(this.axios, this.basePath))
  }
}

/**
 * CredentialsApi - axios parameter creator
 * @export
 */
export const CredentialsApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     * Allows wallets to claim multiple credentials at once. For authentication, it uses a token from the authorization server
     * @summary Allows wallets to claim multiple credentials at once.
     * @param {string} projectId Affinidi project id
     * @param {BatchCredentialInput} batchCredentialInput Request body for batch credential
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    batchCredential: async (
      projectId: string,
      batchCredentialInput: BatchCredentialInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('batchCredential', 'projectId', projectId)
      // verify required parameter 'batchCredentialInput' is not null or undefined
      assertParamExists(
        'batchCredential',
        'batchCredentialInput',
        batchCredentialInput,
      )
      const localVarPath = `/v1/{projectId}/batch_credential`.replace(
        `{${'projectId'}}`,
        encodeURIComponent(String(projectId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication bearerAuth required
      // http bearer authentication required
      await setBearerAuthToObject(localVarHeaderParameter, configuration)

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        batchCredentialInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Issue credential for end user upon presentation a valid access token. Since we don\'t immediate issue credential It\'s expected to return `transaction_id` and use this `transaction_id` to get the deferred credentials
     * @param {string} projectId Affinidi project id
     * @param {CreateCredentialInput} createCredentialInput Request body to issue credentials
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    generateCredentials: async (
      projectId: string,
      createCredentialInput: CreateCredentialInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('generateCredentials', 'projectId', projectId)
      // verify required parameter 'createCredentialInput' is not null or undefined
      assertParamExists(
        'generateCredentials',
        'createCredentialInput',
        createCredentialInput,
      )
      const localVarPath = `/v1/{projectId}/credential`.replace(
        `{${'projectId'}}`,
        encodeURIComponent(String(projectId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication bearerAuth required
      // http bearer authentication required
      await setBearerAuthToObject(localVarHeaderParameter, configuration)

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        createCredentialInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Get claimed credential in the specified range
     * @summary Get claimed credential in the specified range
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} rangeStartTime
     * @param {string} [rangeEndTime]
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {number} [limit]
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getClaimedCredentials: async (
      projectId: string,
      configurationId: string,
      rangeStartTime: string,
      rangeEndTime?: string,
      exclusiveStartKey?: string,
      limit?: number,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('getClaimedCredentials', 'projectId', projectId)
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'getClaimedCredentials',
        'configurationId',
        configurationId,
      )
      // verify required parameter 'rangeStartTime' is not null or undefined
      assertParamExists(
        'getClaimedCredentials',
        'rangeStartTime',
        rangeStartTime,
      )
      const localVarPath =
        `/v1/{projectId}/configurations/{configurationId}/credentials`
          .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
          .replace(
            `{${'configurationId'}}`,
            encodeURIComponent(String(configurationId)),
          )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      if (rangeStartTime !== undefined) {
        localVarQueryParameter['rangeStartTime'] = rangeStartTime
      }

      if (rangeEndTime !== undefined) {
        localVarQueryParameter['rangeEndTime'] = rangeEndTime
      }

      if (exclusiveStartKey !== undefined) {
        localVarQueryParameter['exclusiveStartKey'] = exclusiveStartKey
      }

      if (limit !== undefined) {
        localVarQueryParameter['limit'] = limit
      }

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Get claimed VC linked to the issuanceId
     * @summary Get claimed VC linked to the issuanceId
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} issuanceId issuance id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceIdClaimedCredential: async (
      projectId: string,
      configurationId: string,
      issuanceId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists(
        'getIssuanceIdClaimedCredential',
        'projectId',
        projectId,
      )
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'getIssuanceIdClaimedCredential',
        'configurationId',
        configurationId,
      )
      // verify required parameter 'issuanceId' is not null or undefined
      assertParamExists(
        'getIssuanceIdClaimedCredential',
        'issuanceId',
        issuanceId,
      )
      const localVarPath =
        `/v1/{projectId}/configurations/{configurationId}/issuances/{issuanceId}/credentials`
          .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
          .replace(
            `{${'configurationId'}}`,
            encodeURIComponent(String(configurationId)),
          )
          .replace(`{${'issuanceId'}}`, encodeURIComponent(String(issuanceId)))
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * CredentialsApi - functional programming interface
 * @export
 */
export const CredentialsApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator =
    CredentialsApiAxiosParamCreator(configuration)
  return {
    /**
     * Allows wallets to claim multiple credentials at once. For authentication, it uses a token from the authorization server
     * @summary Allows wallets to claim multiple credentials at once.
     * @param {string} projectId Affinidi project id
     * @param {BatchCredentialInput} batchCredentialInput Request body for batch credential
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async batchCredential(
      projectId: string,
      batchCredentialInput: BatchCredentialInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<BatchCredentialResponse>
    > {
      const localVarAxiosArgs = await localVarAxiosParamCreator.batchCredential(
        projectId,
        batchCredentialInput,
        options,
      )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['CredentialsApi.batchCredential']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Issue credential for end user upon presentation a valid access token. Since we don\'t immediate issue credential It\'s expected to return `transaction_id` and use this `transaction_id` to get the deferred credentials
     * @param {string} projectId Affinidi project id
     * @param {CreateCredentialInput} createCredentialInput Request body to issue credentials
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async generateCredentials(
      projectId: string,
      createCredentialInput: CreateCredentialInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<CredentialResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.generateCredentials(
          projectId,
          createCredentialInput,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['CredentialsApi.generateCredentials']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Get claimed credential in the specified range
     * @summary Get claimed credential in the specified range
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} rangeStartTime
     * @param {string} [rangeEndTime]
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {number} [limit]
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getClaimedCredentials(
      projectId: string,
      configurationId: string,
      rangeStartTime: string,
      rangeEndTime?: string,
      exclusiveStartKey?: string,
      limit?: number,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<ClaimedCredentialListResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getClaimedCredentials(
          projectId,
          configurationId,
          rangeStartTime,
          rangeEndTime,
          exclusiveStartKey,
          limit,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['CredentialsApi.getClaimedCredentials']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Get claimed VC linked to the issuanceId
     * @summary Get claimed VC linked to the issuanceId
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} issuanceId issuance id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getIssuanceIdClaimedCredential(
      projectId: string,
      configurationId: string,
      issuanceId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<ClaimedCredentialResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getIssuanceIdClaimedCredential(
          projectId,
          configurationId,
          issuanceId,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['CredentialsApi.getIssuanceIdClaimedCredential']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * CredentialsApi - factory interface
 * @export
 */
export const CredentialsApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = CredentialsApiFp(configuration)
  return {
    /**
     * Allows wallets to claim multiple credentials at once. For authentication, it uses a token from the authorization server
     * @summary Allows wallets to claim multiple credentials at once.
     * @param {string} projectId Affinidi project id
     * @param {BatchCredentialInput} batchCredentialInput Request body for batch credential
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    batchCredential(
      projectId: string,
      batchCredentialInput: BatchCredentialInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<BatchCredentialResponse> {
      return localVarFp
        .batchCredential(projectId, batchCredentialInput, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Issue credential for end user upon presentation a valid access token. Since we don\'t immediate issue credential It\'s expected to return `transaction_id` and use this `transaction_id` to get the deferred credentials
     * @param {string} projectId Affinidi project id
     * @param {CreateCredentialInput} createCredentialInput Request body to issue credentials
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    generateCredentials(
      projectId: string,
      createCredentialInput: CreateCredentialInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<CredentialResponse> {
      return localVarFp
        .generateCredentials(projectId, createCredentialInput, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Get claimed credential in the specified range
     * @summary Get claimed credential in the specified range
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} rangeStartTime
     * @param {string} [rangeEndTime]
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {number} [limit]
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getClaimedCredentials(
      projectId: string,
      configurationId: string,
      rangeStartTime: string,
      rangeEndTime?: string,
      exclusiveStartKey?: string,
      limit?: number,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<ClaimedCredentialListResponse> {
      return localVarFp
        .getClaimedCredentials(
          projectId,
          configurationId,
          rangeStartTime,
          rangeEndTime,
          exclusiveStartKey,
          limit,
          options,
        )
        .then((request) => request(axios, basePath))
    },
    /**
     * Get claimed VC linked to the issuanceId
     * @summary Get claimed VC linked to the issuanceId
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {string} issuanceId issuance id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getIssuanceIdClaimedCredential(
      projectId: string,
      configurationId: string,
      issuanceId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<ClaimedCredentialResponse> {
      return localVarFp
        .getIssuanceIdClaimedCredential(
          projectId,
          configurationId,
          issuanceId,
          options,
        )
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * CredentialsApi - object-oriented interface
 * @export
 * @class CredentialsApi
 * @extends {BaseAPI}
 */
export class CredentialsApi extends BaseAPI {
  /**
   * Allows wallets to claim multiple credentials at once. For authentication, it uses a token from the authorization server
   * @summary Allows wallets to claim multiple credentials at once.
   * @param {string} projectId Affinidi project id
   * @param {BatchCredentialInput} batchCredentialInput Request body for batch credential
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof CredentialsApi
   */
  public batchCredential(
    projectId: string,
    batchCredentialInput: BatchCredentialInput,
    options?: RawAxiosRequestConfig,
  ) {
    return CredentialsApiFp(this.configuration)
      .batchCredential(projectId, batchCredentialInput, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Issue credential for end user upon presentation a valid access token. Since we don\'t immediate issue credential It\'s expected to return `transaction_id` and use this `transaction_id` to get the deferred credentials
   * @param {string} projectId Affinidi project id
   * @param {CreateCredentialInput} createCredentialInput Request body to issue credentials
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof CredentialsApi
   */
  public generateCredentials(
    projectId: string,
    createCredentialInput: CreateCredentialInput,
    options?: RawAxiosRequestConfig,
  ) {
    return CredentialsApiFp(this.configuration)
      .generateCredentials(projectId, createCredentialInput, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Get claimed credential in the specified range
   * @summary Get claimed credential in the specified range
   * @param {string} projectId project id
   * @param {string} configurationId configuration id
   * @param {string} rangeStartTime
   * @param {string} [rangeEndTime]
   * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
   * @param {number} [limit]
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof CredentialsApi
   */
  public getClaimedCredentials(
    projectId: string,
    configurationId: string,
    rangeStartTime: string,
    rangeEndTime?: string,
    exclusiveStartKey?: string,
    limit?: number,
    options?: RawAxiosRequestConfig,
  ) {
    return CredentialsApiFp(this.configuration)
      .getClaimedCredentials(
        projectId,
        configurationId,
        rangeStartTime,
        rangeEndTime,
        exclusiveStartKey,
        limit,
        options,
      )
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Get claimed VC linked to the issuanceId
   * @summary Get claimed VC linked to the issuanceId
   * @param {string} projectId project id
   * @param {string} configurationId configuration id
   * @param {string} issuanceId issuance id
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof CredentialsApi
   */
  public getIssuanceIdClaimedCredential(
    projectId: string,
    configurationId: string,
    issuanceId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return CredentialsApiFp(this.configuration)
      .getIssuanceIdClaimedCredential(
        projectId,
        configurationId,
        issuanceId,
        options,
      )
      .then((request) => request(this.axios, this.basePath))
  }
}

/**
 * DefaultApi - axios parameter creator
 * @export
 */
export const DefaultApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     * change credential status.
     * @summary change credential status.
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {ChangeCredentialStatusInput} changeCredentialStatusInput Request body for changing credential status
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    changeCredentialStatus: async (
      projectId: string,
      configurationId: string,
      changeCredentialStatusInput: ChangeCredentialStatusInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('changeCredentialStatus', 'projectId', projectId)
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'changeCredentialStatus',
        'configurationId',
        configurationId,
      )
      // verify required parameter 'changeCredentialStatusInput' is not null or undefined
      assertParamExists(
        'changeCredentialStatus',
        'changeCredentialStatusInput',
        changeCredentialStatusInput,
      )
      const localVarPath =
        `/v1/{projectId}/configurations/{configurationId}/issuance/change-status`
          .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
          .replace(
            `{${'configurationId'}}`,
            encodeURIComponent(String(configurationId)),
          )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        changeCredentialStatusInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Retrieve a list of issuance data records.
     * @summary List records
     * @param {string} projectId Affinidi project id
     * @param {string} configurationId The id of the issuance configuration
     * @param {string} [issuanceId] Optional filter to retrieve records for a specific issuance ID
     * @param {number} [limit] Maximum number of records to fetch in a list
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    listIssuanceDataRecords: async (
      projectId: string,
      configurationId: string,
      issuanceId?: string,
      limit?: number,
      exclusiveStartKey?: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('listIssuanceDataRecords', 'projectId', projectId)
      // verify required parameter 'configurationId' is not null or undefined
      assertParamExists(
        'listIssuanceDataRecords',
        'configurationId',
        configurationId,
      )
      const localVarPath =
        `/v1/{projectId}/configurations/{configurationId}/issuance/issuance-data-records`
          .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
          .replace(
            `{${'configurationId'}}`,
            encodeURIComponent(String(configurationId)),
          )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      if (issuanceId !== undefined) {
        localVarQueryParameter['issuanceId'] = issuanceId
      }

      if (limit !== undefined) {
        localVarQueryParameter['limit'] = limit
      }

      if (exclusiveStartKey !== undefined) {
        localVarQueryParameter['exclusiveStartKey'] = exclusiveStartKey
      }

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * DefaultApi - functional programming interface
 * @export
 */
export const DefaultApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator = DefaultApiAxiosParamCreator(configuration)
  return {
    /**
     * change credential status.
     * @summary change credential status.
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {ChangeCredentialStatusInput} changeCredentialStatusInput Request body for changing credential status
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async changeCredentialStatus(
      projectId: string,
      configurationId: string,
      changeCredentialStatusInput: ChangeCredentialStatusInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (axios?: AxiosInstance, basePath?: string) => AxiosPromise<FlowData>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.changeCredentialStatus(
          projectId,
          configurationId,
          changeCredentialStatusInput,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['DefaultApi.changeCredentialStatus']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Retrieve a list of issuance data records.
     * @summary List records
     * @param {string} projectId Affinidi project id
     * @param {string} configurationId The id of the issuance configuration
     * @param {string} [issuanceId] Optional filter to retrieve records for a specific issuance ID
     * @param {number} [limit] Maximum number of records to fetch in a list
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async listIssuanceDataRecords(
      projectId: string,
      configurationId: string,
      issuanceId?: string,
      limit?: number,
      exclusiveStartKey?: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<ListIssuanceRecordResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.listIssuanceDataRecords(
          projectId,
          configurationId,
          issuanceId,
          limit,
          exclusiveStartKey,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['DefaultApi.listIssuanceDataRecords']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * DefaultApi - factory interface
 * @export
 */
export const DefaultApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = DefaultApiFp(configuration)
  return {
    /**
     * change credential status.
     * @summary change credential status.
     * @param {string} projectId project id
     * @param {string} configurationId configuration id
     * @param {ChangeCredentialStatusInput} changeCredentialStatusInput Request body for changing credential status
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    changeCredentialStatus(
      projectId: string,
      configurationId: string,
      changeCredentialStatusInput: ChangeCredentialStatusInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<FlowData> {
      return localVarFp
        .changeCredentialStatus(
          projectId,
          configurationId,
          changeCredentialStatusInput,
          options,
        )
        .then((request) => request(axios, basePath))
    },
    /**
     * Retrieve a list of issuance data records.
     * @summary List records
     * @param {string} projectId Affinidi project id
     * @param {string} configurationId The id of the issuance configuration
     * @param {string} [issuanceId] Optional filter to retrieve records for a specific issuance ID
     * @param {number} [limit] Maximum number of records to fetch in a list
     * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    listIssuanceDataRecords(
      projectId: string,
      configurationId: string,
      issuanceId?: string,
      limit?: number,
      exclusiveStartKey?: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<ListIssuanceRecordResponse> {
      return localVarFp
        .listIssuanceDataRecords(
          projectId,
          configurationId,
          issuanceId,
          limit,
          exclusiveStartKey,
          options,
        )
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * DefaultApi - object-oriented interface
 * @export
 * @class DefaultApi
 * @extends {BaseAPI}
 */
export class DefaultApi extends BaseAPI {
  /**
   * change credential status.
   * @summary change credential status.
   * @param {string} projectId project id
   * @param {string} configurationId configuration id
   * @param {ChangeCredentialStatusInput} changeCredentialStatusInput Request body for changing credential status
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof DefaultApi
   */
  public changeCredentialStatus(
    projectId: string,
    configurationId: string,
    changeCredentialStatusInput: ChangeCredentialStatusInput,
    options?: RawAxiosRequestConfig,
  ) {
    return DefaultApiFp(this.configuration)
      .changeCredentialStatus(
        projectId,
        configurationId,
        changeCredentialStatusInput,
        options,
      )
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Retrieve a list of issuance data records.
   * @summary List records
   * @param {string} projectId Affinidi project id
   * @param {string} configurationId The id of the issuance configuration
   * @param {string} [issuanceId] Optional filter to retrieve records for a specific issuance ID
   * @param {number} [limit] Maximum number of records to fetch in a list
   * @param {string} [exclusiveStartKey] exclusiveStartKey for retrieving the next batch of data.
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof DefaultApi
   */
  public listIssuanceDataRecords(
    projectId: string,
    configurationId: string,
    issuanceId?: string,
    limit?: number,
    exclusiveStartKey?: string,
    options?: RawAxiosRequestConfig,
  ) {
    return DefaultApiFp(this.configuration)
      .listIssuanceDataRecords(
        projectId,
        configurationId,
        issuanceId,
        limit,
        exclusiveStartKey,
        options,
      )
      .then((request) => request(this.axios, this.basePath))
  }
}

/**
 * IssuanceApi - axios parameter creator
 * @export
 */
export const IssuanceApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     * Get issuance status
     * @param {string} issuanceId
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    issuanceState: async (
      issuanceId: string,
      projectId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'issuanceId' is not null or undefined
      assertParamExists('issuanceState', 'issuanceId', issuanceId)
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('issuanceState', 'projectId', projectId)
      const localVarPath = `/v1/{projectId}/issuance/state/{issuanceId}`
        .replace(`{${'issuanceId'}}`, encodeURIComponent(String(issuanceId)))
        .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Endpoint to issue credentials directly without following OID4VCI flow
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    issueCredentials: async (
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('issueCredentials', 'projectId', projectId)
      // verify required parameter 'startIssuanceInput' is not null or undefined
      assertParamExists(
        'issueCredentials',
        'startIssuanceInput',
        startIssuanceInput,
      )
      const localVarPath = `/v1/{projectId}/credential/issue`.replace(
        `{${'projectId'}}`,
        encodeURIComponent(String(projectId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        startIssuanceInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * List all issuances for Project
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    listIssuance: async (
      projectId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('listIssuance', 'projectId', projectId)
      const localVarPath = `/v1/{projectId}/issuance`.replace(
        `{${'projectId'}}`,
        encodeURIComponent(String(projectId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
    /**
     * Endpoint used b websites to start the issuance process
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    startIssuance: async (
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('startIssuance', 'projectId', projectId)
      // verify required parameter 'startIssuanceInput' is not null or undefined
      assertParamExists(
        'startIssuance',
        'startIssuanceInput',
        startIssuanceInput,
      )
      const localVarPath = `/v1/{projectId}/issuance/start`.replace(
        `{${'projectId'}}`,
        encodeURIComponent(String(projectId)),
      )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'POST',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      // authentication ProjectTokenAuth required
      await setApiKeyToObject(
        localVarHeaderParameter,
        'authorization',
        configuration,
      )

      localVarHeaderParameter['Content-Type'] = 'application/json'

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }
      localVarRequestOptions.data = serializeDataIfNeeded(
        startIssuanceInput,
        localVarRequestOptions,
        configuration,
      )

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * IssuanceApi - functional programming interface
 * @export
 */
export const IssuanceApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator = IssuanceApiAxiosParamCreator(configuration)
  return {
    /**
     * Get issuance status
     * @param {string} issuanceId
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async issuanceState(
      issuanceId: string,
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<IssuanceStateResponse>
    > {
      const localVarAxiosArgs = await localVarAxiosParamCreator.issuanceState(
        issuanceId,
        projectId,
        options,
      )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['IssuanceApi.issuanceState']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Endpoint to issue credentials directly without following OID4VCI flow
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async issueCredentials(
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<CredentialResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.issueCredentials(
          projectId,
          startIssuanceInput,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['IssuanceApi.issueCredentials']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * List all issuances for Project
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async listIssuance(
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<ListIssuanceResponse>
    > {
      const localVarAxiosArgs = await localVarAxiosParamCreator.listIssuance(
        projectId,
        options,
      )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['IssuanceApi.listIssuance']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
    /**
     * Endpoint used b websites to start the issuance process
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async startIssuance(
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<StartIssuanceResponse>
    > {
      const localVarAxiosArgs = await localVarAxiosParamCreator.startIssuance(
        projectId,
        startIssuanceInput,
        options,
      )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['IssuanceApi.startIssuance']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * IssuanceApi - factory interface
 * @export
 */
export const IssuanceApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = IssuanceApiFp(configuration)
  return {
    /**
     * Get issuance status
     * @param {string} issuanceId
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    issuanceState(
      issuanceId: string,
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<IssuanceStateResponse> {
      return localVarFp
        .issuanceState(issuanceId, projectId, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Endpoint to issue credentials directly without following OID4VCI flow
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    issueCredentials(
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<CredentialResponse> {
      return localVarFp
        .issueCredentials(projectId, startIssuanceInput, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * List all issuances for Project
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    listIssuance(
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<ListIssuanceResponse> {
      return localVarFp
        .listIssuance(projectId, options)
        .then((request) => request(axios, basePath))
    },
    /**
     * Endpoint used b websites to start the issuance process
     * @param {string} projectId Affinidi project id
     * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    startIssuance(
      projectId: string,
      startIssuanceInput: StartIssuanceInput,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<StartIssuanceResponse> {
      return localVarFp
        .startIssuance(projectId, startIssuanceInput, options)
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * IssuanceApi - object-oriented interface
 * @export
 * @class IssuanceApi
 * @extends {BaseAPI}
 */
export class IssuanceApi extends BaseAPI {
  /**
   * Get issuance status
   * @param {string} issuanceId
   * @param {string} projectId Affinidi project id
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof IssuanceApi
   */
  public issuanceState(
    issuanceId: string,
    projectId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return IssuanceApiFp(this.configuration)
      .issuanceState(issuanceId, projectId, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Endpoint to issue credentials directly without following OID4VCI flow
   * @param {string} projectId Affinidi project id
   * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof IssuanceApi
   */
  public issueCredentials(
    projectId: string,
    startIssuanceInput: StartIssuanceInput,
    options?: RawAxiosRequestConfig,
  ) {
    return IssuanceApiFp(this.configuration)
      .issueCredentials(projectId, startIssuanceInput, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * List all issuances for Project
   * @param {string} projectId Affinidi project id
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof IssuanceApi
   */
  public listIssuance(projectId: string, options?: RawAxiosRequestConfig) {
    return IssuanceApiFp(this.configuration)
      .listIssuance(projectId, options)
      .then((request) => request(this.axios, this.basePath))
  }

  /**
   * Endpoint used b websites to start the issuance process
   * @param {string} projectId Affinidi project id
   * @param {StartIssuanceInput} startIssuanceInput Request body to start issuance
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof IssuanceApi
   */
  public startIssuance(
    projectId: string,
    startIssuanceInput: StartIssuanceInput,
    options?: RawAxiosRequestConfig,
  ) {
    return IssuanceApiFp(this.configuration)
      .startIssuance(projectId, startIssuanceInput, options)
      .then((request) => request(this.axios, this.basePath))
  }
}

/**
 * OfferApi - axios parameter creator
 * @export
 */
export const OfferApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     * Endpoint used to return Credential Offer details, used with `credential_offer_uri` response
     * @param {string} projectId Affinidi project id
     * @param {string} issuanceId issuanceId from credential_offer_uri
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getCredentialOffer: async (
      projectId: string,
      issuanceId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists('getCredentialOffer', 'projectId', projectId)
      // verify required parameter 'issuanceId' is not null or undefined
      assertParamExists('getCredentialOffer', 'issuanceId', issuanceId)
      const localVarPath = `/v1/{projectId}/offers/{issuanceId}`
        .replace(`{${'projectId'}}`, encodeURIComponent(String(projectId)))
        .replace(`{${'issuanceId'}}`, encodeURIComponent(String(issuanceId)))
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * OfferApi - functional programming interface
 * @export
 */
export const OfferApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator = OfferApiAxiosParamCreator(configuration)
  return {
    /**
     * Endpoint used to return Credential Offer details, used with `credential_offer_uri` response
     * @param {string} projectId Affinidi project id
     * @param {string} issuanceId issuanceId from credential_offer_uri
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getCredentialOffer(
      projectId: string,
      issuanceId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<CredentialOfferResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getCredentialOffer(
          projectId,
          issuanceId,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['OfferApi.getCredentialOffer']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * OfferApi - factory interface
 * @export
 */
export const OfferApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = OfferApiFp(configuration)
  return {
    /**
     * Endpoint used to return Credential Offer details, used with `credential_offer_uri` response
     * @param {string} projectId Affinidi project id
     * @param {string} issuanceId issuanceId from credential_offer_uri
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getCredentialOffer(
      projectId: string,
      issuanceId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<CredentialOfferResponse> {
      return localVarFp
        .getCredentialOffer(projectId, issuanceId, options)
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * OfferApi - object-oriented interface
 * @export
 * @class OfferApi
 * @extends {BaseAPI}
 */
export class OfferApi extends BaseAPI {
  /**
   * Endpoint used to return Credential Offer details, used with `credential_offer_uri` response
   * @param {string} projectId Affinidi project id
   * @param {string} issuanceId issuanceId from credential_offer_uri
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof OfferApi
   */
  public getCredentialOffer(
    projectId: string,
    issuanceId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return OfferApiFp(this.configuration)
      .getCredentialOffer(projectId, issuanceId, options)
      .then((request) => request(this.axios, this.basePath))
  }
}

/**
 * WellKnownApi - axios parameter creator
 * @export
 */
export const WellKnownApiAxiosParamCreator = function (
  configuration?: Configuration,
) {
  return {
    /**
     *
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getWellKnownOpenIdCredentialIssuer: async (
      projectId: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      // verify required parameter 'projectId' is not null or undefined
      assertParamExists(
        'getWellKnownOpenIdCredentialIssuer',
        'projectId',
        projectId,
      )
      const localVarPath =
        `/v1/{projectId}/.well-known/openid-credential-issuer`.replace(
          `{${'projectId'}}`,
          encodeURIComponent(String(projectId)),
        )
      // use dummy base URL string because the URL constructor only accepts absolute URLs.
      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL)
      let baseOptions
      if (configuration) {
        baseOptions = configuration.baseOptions
      }

      const localVarRequestOptions = {
        method: 'GET',
        ...baseOptions,
        ...options,
      }
      const localVarHeaderParameter = {} as any
      const localVarQueryParameter = {} as any

      setSearchParams(localVarUrlObj, localVarQueryParameter)
      let headersFromBaseOptions =
        baseOptions && baseOptions.headers ? baseOptions.headers : {}
      localVarRequestOptions.headers = {
        ...localVarHeaderParameter,
        ...headersFromBaseOptions,
        ...options.headers,
      }

      return {
        url: toPathString(localVarUrlObj),
        options: localVarRequestOptions,
      }
    },
  }
}

/**
 * WellKnownApi - functional programming interface
 * @export
 */
export const WellKnownApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator = WellKnownApiAxiosParamCreator(configuration)
  return {
    /**
     *
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    async getWellKnownOpenIdCredentialIssuer(
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): Promise<
      (
        axios?: AxiosInstance,
        basePath?: string,
      ) => AxiosPromise<WellKnownOpenIdCredentialIssuerResponse>
    > {
      const localVarAxiosArgs =
        await localVarAxiosParamCreator.getWellKnownOpenIdCredentialIssuer(
          projectId,
          options,
        )
      const localVarOperationServerIndex = configuration?.serverIndex ?? 0
      const localVarOperationServerBasePath =
        operationServerMap['WellKnownApi.getWellKnownOpenIdCredentialIssuer']?.[
          localVarOperationServerIndex
        ]?.url
      return (axios, basePath) =>
        createRequestFunction(
          localVarAxiosArgs,
          globalAxios,
          BASE_PATH,
          configuration,
        )(axios, localVarOperationServerBasePath || basePath)
    },
  }
}

/**
 * WellKnownApi - factory interface
 * @export
 */
export const WellKnownApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = WellKnownApiFp(configuration)
  return {
    /**
     *
     * @param {string} projectId Affinidi project id
     * @param {*} [options] Override http request option.
     * @throws {RequiredError}
     */
    getWellKnownOpenIdCredentialIssuer(
      projectId: string,
      options?: RawAxiosRequestConfig,
    ): AxiosPromise<WellKnownOpenIdCredentialIssuerResponse> {
      return localVarFp
        .getWellKnownOpenIdCredentialIssuer(projectId, options)
        .then((request) => request(axios, basePath))
    },
  }
}

/**
 * WellKnownApi - object-oriented interface
 * @export
 * @class WellKnownApi
 * @extends {BaseAPI}
 */
export class WellKnownApi extends BaseAPI {
  /**
   *
   * @param {string} projectId Affinidi project id
   * @param {*} [options] Override http request option.
   * @throws {RequiredError}
   * @memberof WellKnownApi
   */
  public getWellKnownOpenIdCredentialIssuer(
    projectId: string,
    options?: RawAxiosRequestConfig,
  ) {
    return WellKnownApiFp(this.configuration)
      .getWellKnownOpenIdCredentialIssuer(projectId, options)
      .then((request) => request(this.axios, this.basePath))
  }
}