import {z} from 'zod'

export type ClaimType = 'identity' | 'nationalities' | 'residence' | 'tax_residencies' | 'fatca_status' | 'pep_status' | 'education_level' | 'employment' | 'financial_profile' | 'investment_experience' | 'expected_activity' | 'relationships' | 'registration' | 'contact_details' | 'lei' | 'registered_address' | 'operating_address' | 'business_nature';

export type ClaimStatus = 'pending' | 'verified';

export type GetApiPersonsPersonIdClaimsArgs = {person_id: string, claim_type?: (ClaimType | null) | undefined, status?: (ClaimStatus | null) | undefined, include_history?: (boolean | null) | undefined};

export type GetApiPersonsPersonIdClaimsOptions = {baseUrl?: string | undefined, HTTPBearer?: string | undefined, fetch?: typeof fetch | undefined};

export const claimType = z.enum(["identity", "nationalities", "residence", "tax_residencies", "fatca_status", "pep_status", "education_level", "employment", "financial_profile", "investment_experience", "expected_activity", "relationships", "registration", "contact_details", "lei", "registered_address", "operating_address", "business_nature"]);

export const identityClaimSpec = z.object({claim_type: z.literal("identity"), date_of_birth: z.string(), first_name: z.string(), last_name: z.string()});

export const nationalityBasis = z.enum(["birth", "naturalisation", "descent", "marriage", "investment_programme", "other"]);

export const nationalityEntry = z.object({basis: nationalityBasis.nullable().optional(), country_code: z.string()});

export const nationalitiesClaimSpec = z.object({claim_type: z.literal("nationalities"), nationalities: z.array(nationalityEntry).optional()});

export const residenceClaimSpec = z.object({city: z.string(), claim_type: z.literal("residence"), country_code: z.string(), district_county: z.string().nullable().optional(), line1: z.string(), line2: z.string().nullable().optional(), line3: z.string().nullable().optional(), postal_code: z.string()});

export const tinExemptionReason = z.enum(["not_issued", "pending_application", "not_required"]);

export const taxResidencyEntry = z.object({country_code: z.string(), tin: z.string().nullable().optional(), tin_exemption_reason: tinExemptionReason.nullable().optional()});

export const taxResidenciesClaimSpec = z.object({claim_type: z.literal("tax_residencies"), tax_residencies: z.array(taxResidencyEntry).optional()});

export const fatcaStatusClaimSpec = z.object({claim_type: z.literal("fatca_status"), is_us_person: z.boolean()});

export const pepStatusClaimSpec = z.object({claim_type: z.literal("pep_status"), has_pep_association: z.boolean(), is_pep: z.boolean(), pep_associate_name: z.string().nullable().optional(), pep_associate_relationship: z.string().nullable().optional(), pep_role: z.string().nullable().optional(), pep_role_end_date: z.string().nullable().optional(), pep_role_start_date: z.string().nullable().optional()});

export const claimEducationLevel = z.enum(["none", "secondary", "bachelors", "masters", "doctorate", "professional"]);

export const educationLevelClaimSpec = z.object({claim_type: z.literal("education_level"), education_level: claimEducationLevel});

export const claimEmploymentStatus = z.enum(["employed", "self_employed", "retired", "student", "unemployed"]);

export const claimIndustry = z.enum(["accountancy", "admin_secretarial", "agricultural", "arms_trade", "catering_hospitality", "company_services", "consulting", "creative_media", "defence_military", "education", "emergency_services", "energy", "export_import", "financial_services", "gambling", "government_public_sector", "health_medical", "legal", "leisure_entertainment_tourism", "manufacturing", "marketing_pr_advertising", "ngo", "nonprofit_charity", "oil_gas_mining", "pharmaceuticals", "precious_metals_stones", "professional_services", "property_construction_trade", "retail", "social_care_services", "technology", "telecommunications", "transport_logistics", "adult_entertainment", "cannabis_cbd", "cryptocurrencies", "embassy_consulate", "other"]);

export const employmentClaimSpec = z.object({claim_type: z.literal("employment"), employment_status: claimEmploymentStatus, industry: claimIndustry.nullable().optional(), industry_other: z.string().nullable().optional()});

export const eurAmountBand = z.enum(["lt_50k", "50k_100k", "100k_250k", "250k_500k", "500k_1m", "1m_3m", "gt_3m"]);

export const claimIncomeSource = z.enum(["salary", "pension", "rental_income", "dividends", "interest"]);

export const claimWealthSource = z.enum(["savings", "inheritance", "trust_fund", "investments", "borrowings", "real_estate"]);

export const financialProfileClaimSpec = z.object({annual_income_eur: eurAmountBand, claim_type: z.literal("financial_profile"), income_sources: z.array(claimIncomeSource), net_worth_eur: eurAmountBand, wealth_sources: z.array(claimWealthSource)});

export const claimAssetClass = z.enum(["treasury_bills", "bonds", "equities", "etfs", "mutual_funds", "fx", "cfds", "derivatives", "crypto"]);

export const investmentExperienceClaimSpec = z.object({asset_classes: z.array(claimAssetClass).optional(), claim_type: z.literal("investment_experience"), has_prior_experience: z.boolean()});

export const expectedActivityClaimSpec = z.object({annual_transactions: z.string(), asset_classes: z.array(z.string()), claim_type: z.literal("expected_activity"), funding_currency: z.string(), investment_amount: z.string()});

export const controlType = z.enum(["ownership", "voting", "other"]);

export const personRelationshipType = z.enum(["director", "shareholder", "beneficial_owner", "trustee", "settlor", "authorised_signatory", "senior_management"]);

export const relationshipEntryOutput = z.object({appointment_date: z.string().nullable().optional(), authority_scope: z.string().nullable().optional(), control_type: controlType.nullable().optional(), end_date: z.string().nullable().optional(), ownership_percentage: z.string().nullable().optional(), position: z.string().nullable().optional(), related_person: z.string(), relationship_type: personRelationshipType});

export const relationshipsClaimSpecOutput = z.object({claim_type: z.literal("relationships"), relationships: z.array(relationshipEntryOutput)});

export const claimRegistrationEntityType = z.enum(["private_company", "public_company", "listed_company", "investment_firm", "pension_provident_fund", "investment_fund", "insurance_firm", "trust", "partnership", "bank_emi"]);

export const registrationClaimSpec = z.object({claim_type: z.literal("registration"), country_of_incorporation: z.string(), date_of_incorporation: z.string(), entity_type: claimRegistrationEntityType, legal_name: z.string(), registration_number: z.string(), trading_name: z.string().nullable().optional()});

export const contactDetailsClaimSpec = z.object({claim_type: z.literal("contact_details"), email: z.string().nullable().optional(), phone_number: z.string()});

export const leiClaimSpec = z.object({claim_type: z.literal("lei"), expiry_date: z.string(), identifier: z.string()});

export const registeredAddressClaimSpec = z.object({city: z.string(), claim_type: z.literal("registered_address"), country_code: z.string(), district_county: z.string().nullable().optional(), line1: z.string(), line2: z.string().nullable().optional(), line3: z.string().nullable().optional(), operating_address_is_same: z.boolean().optional(), postal_code: z.string()});

export const operatingAddressClaimSpec = z.object({city: z.string(), claim_type: z.literal("operating_address"), country_code: z.string(), district_county: z.string().nullable().optional(), line1: z.string(), line2: z.string().nullable().optional(), line3: z.string().nullable().optional(), postal_code: z.string()});

export const businessNatureClaimSpec = z.object({annual_turnover_eur: eurAmountBand, business_activity: claimIndustry, business_activity_other: z.string().nullable().optional(), claim_type: z.literal("business_nature"), has_nominee_shareholders: z.boolean(), has_shell_bank_relationships: z.boolean(), is_regulated: z.boolean(), issues_bearer_shares: z.boolean(), license_number: z.string().nullable().optional()});

export const claimSourceRole = z.enum(["supports", "confirms"]);

export const claimSourceType = z.enum(["form_submission", "meeting_transcript", "file", "api", "provider"]);

export const claimSource = z.object({locator: z.record(z.string(), z.unknown()), role: claimSourceRole, source: z.string().nullable(), source_type: claimSourceType});

export const embeddedClaimVersion = z.object({created_at: z.string(), data: z.discriminatedUnion("claim_type", [identityClaimSpec, nationalitiesClaimSpec, residenceClaimSpec, taxResidenciesClaimSpec, fatcaStatusClaimSpec, pepStatusClaimSpec, educationLevelClaimSpec, employmentClaimSpec, financialProfileClaimSpec, investmentExperienceClaimSpec, expectedActivityClaimSpec, relationshipsClaimSpecOutput, registrationClaimSpec, contactDetailsClaimSpec, leiClaimSpec, registeredAddressClaimSpec, operatingAddressClaimSpec, businessNatureClaimSpec]), id: z.string(), number: z.number().int(), sources: z.array(claimSource), status: z.enum(["unverified", "verified"]), verified_at: z.string().nullable()});

export const claim = z.object({archived_at: z.string().nullable(), claim_type: claimType, created_at: z.string(), id: z.string(), is_archivable: z.boolean(), latest_verified_version: embeddedClaimVersion.nullable(), latest_version: embeddedClaimVersion, person: z.string(), versions: z.array(embeddedClaimVersion).nullable().optional()});

export const getApiPersonsPersonIdClaimsResponse = z.array(claim);

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * List claims for a person
 * 
 * GET /persons/{person_id}/claims
 */
export const getApiPersonsPersonIdClaims = async (args: GetApiPersonsPersonIdClaimsArgs, options?: GetApiPersonsPersonIdClaimsOptions) => {
const {baseUrl = "https://api.joinsophic.com", fetch: fetchFn = fetch, HTTPBearer} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.claim_type != null) query.append("claim_type", String(args.claim_type))
if (args.status != null) query.append("status", String(args.status))
if (args.include_history != null) query.append("include_history", String(args.include_history))
if (HTTPBearer !== undefined) headers.set('authorization', `Bearer ${HTTPBearer}`)

const url = `${baseUrl.replace(/\/+$/, '')}/persons/${encodeURIComponent(String(args.person_id))}/claims${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(getApiPersonsPersonIdClaimsResponse, await res.json())
};