@unified-api/typescript-sdk 2.73.17 → 2.73.19

package/bin/mcp-server.js

@@ -34231,9 +34231,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0",
-    sdkVersion: "2.73.17",
-    genVersion: "2.687.1",
-    userAgent: "speakeasy-sdk/typescript 2.73.17 2.687.1 1.0 @unified-api/typescript-sdk"
+    sdkVersion: "2.73.19",
+    genVersion: "2.687.13",
+    userAgent: "speakeasy-sdk/typescript 2.73.19 2.687.13 1.0 @unified-api/typescript-sdk"
   };
 });
 
@@ -42088,7 +42088,8 @@ var init_propertyconnectioncategories = __esm(() => {
     Lms: "lms",
     Repo: "repo",
     Metadata: "metadata",
-    Calendar: "calendar"
+    Calendar: "calendar",
+    Verification: "verification"
   };
   PropertyConnectionCategories$inboundSchema = unionType([
     nativeEnumType(PropertyConnectionCategories),
@@ -42160,6 +42161,9 @@ var init_propertyconnectionpermissions = __esm(() => {
     CommerceLocationWrite: "commerce_location_write",
     CommerceReviewRead: "commerce_review_read",
     CommerceReviewWrite: "commerce_review_write",
+    VerificationPackageRead: "verification_package_read",
+    VerificationRequestRead: "verification_request_read",
+    VerificationRequestWrite: "verification_request_write",
     AtsActivityRead: "ats_activity_read",
     AtsActivityWrite: "ats_activity_write",
     AtsApplicationRead: "ats_application_read",
@@ -44115,6 +44119,7 @@ var init_genaiprompt = __esm(() => {
   init_genaicontent();
   GenaiPrompt$inboundSchema = objectType({
     max_tokens: numberType().optional(),
+    mcp_url: stringType().optional(),
     messages: arrayType(GenaiContent$inboundSchema).optional(),
     model_id: stringType().optional(),
     raw: recordType(anyType()).optional(),
@@ -44124,12 +44129,14 @@ var init_genaiprompt = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       max_tokens: "maxTokens",
+      mcp_url: "mcpUrl",
       model_id: "modelId",
       tokens_used: "tokensUsed"
     });
   });
   GenaiPrompt$outboundSchema = objectType({
     maxTokens: numberType().optional(),
+    mcpUrl: stringType().optional(),
     messages: arrayType(GenaiContent$outboundSchema).optional(),
     modelId: stringType().optional(),
     raw: recordType(anyType()).optional(),
@@ -44139,6 +44146,7 @@ var init_genaiprompt = __esm(() => {
   }).transform((v2) => {
     return remap(v2, {
       maxTokens: "max_tokens",
+      mcpUrl: "mcp_url",
       modelId: "model_id",
       tokensUsed: "tokens_used"
     });
@@ -45490,7 +45498,8 @@ var init_propertyintegrationcategories = __esm(() => {
     Lms: "lms",
     Repo: "repo",
     Metadata: "metadata",
-    Calendar: "calendar"
+    Calendar: "calendar",
+    Verification: "verification"
   };
   PropertyIntegrationCategories$inboundSchema = unionType([
     nativeEnumType(PropertyIntegrationCategories),
@@ -50173,6 +50182,456 @@ var init_ucrecording = __esm(() => {
   })(UcRecording$ ||= {});
 });
 
+// src/sdk/models/shared/verificationaddress.ts
+var VerificationAddress$inboundSchema, VerificationAddress$outboundSchema, VerificationAddress$;
+var init_verificationaddress = __esm(() => {
+  init_esm();
+  init_primitives();
+  VerificationAddress$inboundSchema = objectType({
+    address1: stringType().optional(),
+    address2: stringType().optional(),
+    city: stringType().optional(),
+    country: stringType().optional(),
+    country_code: stringType().optional(),
+    postal_code: stringType().optional(),
+    region: stringType().optional(),
+    region_code: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      country_code: "countryCode",
+      postal_code: "postalCode",
+      region_code: "regionCode"
+    });
+  });
+  VerificationAddress$outboundSchema = objectType({
+    address1: stringType().optional(),
+    address2: stringType().optional(),
+    city: stringType().optional(),
+    country: stringType().optional(),
+    countryCode: stringType().optional(),
+    postalCode: stringType().optional(),
+    region: stringType().optional(),
+    regionCode: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      countryCode: "country_code",
+      postalCode: "postal_code",
+      regionCode: "region_code"
+    });
+  });
+  ((VerificationAddress$) => {
+    VerificationAddress$.inboundSchema = VerificationAddress$inboundSchema;
+    VerificationAddress$.outboundSchema = VerificationAddress$outboundSchema;
+  })(VerificationAddress$ ||= {});
+});
+
+// src/sdk/models/shared/verificationparameter.ts
+var VerificationParameterType, VerificationParameterType$inboundSchema, VerificationParameterType$outboundSchema, VerificationParameterType$, VerificationParameter$inboundSchema, VerificationParameter$outboundSchema, VerificationParameter$;
+var init_verificationparameter = __esm(() => {
+  init_esm();
+  init_primitives();
+  VerificationParameterType = {
+    Text: "TEXT",
+    Number: "NUMBER",
+    MultipleChoice: "MULTIPLE_CHOICE",
+    MultipleSelect: "MULTIPLE_SELECT",
+    Date: "DATE",
+    File: "FILE"
+  };
+  VerificationParameterType$inboundSchema = unionType([
+    nativeEnumType(VerificationParameterType),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  VerificationParameterType$outboundSchema = unionType([
+    nativeEnumType(VerificationParameterType),
+    stringType().and(custom())
+  ]);
+  ((VerificationParameterType$) => {
+    VerificationParameterType$.inboundSchema = VerificationParameterType$inboundSchema;
+    VerificationParameterType$.outboundSchema = VerificationParameterType$outboundSchema;
+  })(VerificationParameterType$ ||= {});
+  VerificationParameter$inboundSchema = objectType({
+    file_types: arrayType(stringType()).optional(),
+    id: stringType().optional(),
+    is_required: booleanType().optional(),
+    name: stringType(),
+    options: arrayType(stringType()).optional(),
+    public_question: stringType().optional(),
+    type: VerificationParameterType$inboundSchema.optional(),
+    valid_regions: arrayType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      file_types: "fileTypes",
+      is_required: "isRequired",
+      public_question: "publicQuestion",
+      valid_regions: "validRegions"
+    });
+  });
+  VerificationParameter$outboundSchema = objectType({
+    fileTypes: arrayType(stringType()).optional(),
+    id: stringType().optional(),
+    isRequired: booleanType().optional(),
+    name: stringType(),
+    options: arrayType(stringType()).optional(),
+    publicQuestion: stringType().optional(),
+    type: VerificationParameterType$outboundSchema.optional(),
+    validRegions: arrayType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      fileTypes: "file_types",
+      isRequired: "is_required",
+      publicQuestion: "public_question",
+      validRegions: "valid_regions"
+    });
+  });
+  ((VerificationParameter$) => {
+    VerificationParameter$.inboundSchema = VerificationParameter$inboundSchema;
+    VerificationParameter$.outboundSchema = VerificationParameter$outboundSchema;
+  })(VerificationParameter$ ||= {});
+});
+
+// src/sdk/models/shared/verificationtime.ts
+var VerificationTime$inboundSchema, VerificationTime$outboundSchema, VerificationTime$;
+var init_verificationtime = __esm(() => {
+  init_esm();
+  init_primitives();
+  VerificationTime$inboundSchema = objectType({
+    milliseconds: numberType().optional(),
+    valid_regions: arrayType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      valid_regions: "validRegions"
+    });
+  });
+  VerificationTime$outboundSchema = objectType({
+    milliseconds: numberType().optional(),
+    validRegions: arrayType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      validRegions: "valid_regions"
+    });
+  });
+  ((VerificationTime$) => {
+    VerificationTime$.inboundSchema = VerificationTime$inboundSchema;
+    VerificationTime$.outboundSchema = VerificationTime$outboundSchema;
+  })(VerificationTime$ ||= {});
+});
+
+// src/sdk/models/shared/verificationpackage.ts
+var VerificationPackageType, VerificationPackageType$inboundSchema, VerificationPackageType$outboundSchema, VerificationPackageType$, VerificationPackage$inboundSchema, VerificationPackage$outboundSchema, VerificationPackage$;
+var init_verificationpackage = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_verificationparameter();
+  init_verificationtime();
+  VerificationPackageType = {
+    IdentityVerification: "IDENTITY_VERIFICATION",
+    Screening: "SCREENING",
+    BackgroundCheck: "BACKGROUND_CHECK",
+    EmploymentVerification: "EMPLOYMENT_VERIFICATION",
+    EducationVerification: "EDUCATION_VERIFICATION",
+    CreditCheck: "CREDIT_CHECK",
+    FraudPrevention: "FRAUD_PREVENTION",
+    Other: "OTHER"
+  };
+  VerificationPackageType$inboundSchema = unionType([
+    nativeEnumType(VerificationPackageType),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  VerificationPackageType$outboundSchema = unionType([
+    nativeEnumType(VerificationPackageType),
+    stringType().and(custom())
+  ]);
+  ((VerificationPackageType$) => {
+    VerificationPackageType$.inboundSchema = VerificationPackageType$inboundSchema;
+    VerificationPackageType$.outboundSchema = VerificationPackageType$outboundSchema;
+  })(VerificationPackageType$ ||= {});
+  VerificationPackage$inboundSchema = objectType({
+    aliases: arrayType(stringType()).optional(),
+    average_processing_times: arrayType(VerificationTime$inboundSchema).optional(),
+    cost_amount: numberType().optional(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    currency: stringType().optional(),
+    description: stringType().optional(),
+    has_redirect_url: booleanType().optional(),
+    has_target_url: booleanType().optional(),
+    id: stringType(),
+    info_url: stringType().optional(),
+    max_score: numberType().optional(),
+    name: stringType(),
+    needs_ip_address: booleanType().optional(),
+    parameters: arrayType(VerificationParameter$inboundSchema).optional(),
+    raw: recordType(anyType()).optional(),
+    tags: arrayType(stringType()).optional(),
+    type: VerificationPackageType$inboundSchema,
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      average_processing_times: "averageProcessingTimes",
+      cost_amount: "costAmount",
+      created_at: "createdAt",
+      has_redirect_url: "hasRedirectUrl",
+      has_target_url: "hasTargetUrl",
+      info_url: "infoUrl",
+      max_score: "maxScore",
+      needs_ip_address: "needsIpAddress",
+      updated_at: "updatedAt"
+    });
+  });
+  VerificationPackage$outboundSchema = objectType({
+    aliases: arrayType(stringType()).optional(),
+    averageProcessingTimes: arrayType(VerificationTime$outboundSchema).optional(),
+    costAmount: numberType().optional(),
+    createdAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    currency: stringType().optional(),
+    description: stringType().optional(),
+    hasRedirectUrl: booleanType().optional(),
+    hasTargetUrl: booleanType().optional(),
+    id: stringType(),
+    infoUrl: stringType().optional(),
+    maxScore: numberType().optional(),
+    name: stringType(),
+    needsIpAddress: booleanType().optional(),
+    parameters: arrayType(VerificationParameter$outboundSchema).optional(),
+    raw: recordType(anyType()).optional(),
+    tags: arrayType(stringType()).optional(),
+    type: VerificationPackageType$outboundSchema,
+    updatedAt: dateType().transform((v2) => v2.toISOString()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      averageProcessingTimes: "average_processing_times",
+      costAmount: "cost_amount",
+      createdAt: "created_at",
+      hasRedirectUrl: "has_redirect_url",
+      hasTargetUrl: "has_target_url",
+      infoUrl: "info_url",
+      maxScore: "max_score",
+      needsIpAddress: "needs_ip_address",
+      updatedAt: "updated_at"
+    });
+  });
+  ((VerificationPackage$) => {
+    VerificationPackage$.inboundSchema = VerificationPackage$inboundSchema;
+    VerificationPackage$.outboundSchema = VerificationPackage$outboundSchema;
+  })(VerificationPackage$ ||= {});
+});
+
+// src/sdk/models/shared/verificationparameterinput.ts
+var VerificationParameterInput$inboundSchema, VerificationParameterInput$outboundSchema, VerificationParameterInput$;
+var init_verificationparameterinput = __esm(() => {
+  init_esm();
+  VerificationParameterInput$inboundSchema = objectType({
+    id: stringType().optional(),
+    inputs: arrayType(stringType()).optional(),
+    name: stringType().optional()
+  });
+  VerificationParameterInput$outboundSchema = objectType({
+    id: stringType().optional(),
+    inputs: arrayType(stringType()).optional(),
+    name: stringType().optional()
+  });
+  ((VerificationParameterInput$) => {
+    VerificationParameterInput$.inboundSchema = VerificationParameterInput$inboundSchema;
+    VerificationParameterInput$.outboundSchema = VerificationParameterInput$outboundSchema;
+  })(VerificationParameterInput$ ||= {});
+});
+
+// src/sdk/models/shared/verificationresponsedetail.ts
+var VerificationResponseDetail$inboundSchema, VerificationResponseDetail$outboundSchema, VerificationResponseDetail$;
+var init_verificationresponsedetail = __esm(() => {
+  init_esm();
+  init_primitives();
+  VerificationResponseDetail$inboundSchema = objectType({
+    download_url: stringType().optional(),
+    is_failed_reason: booleanType().optional(),
+    is_private: booleanType().optional(),
+    parameter_id: stringType().optional(),
+    text: stringType().optional(),
+    title: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      download_url: "downloadUrl",
+      is_failed_reason: "isFailedReason",
+      is_private: "isPrivate",
+      parameter_id: "parameterId"
+    });
+  });
+  VerificationResponseDetail$outboundSchema = objectType({
+    downloadUrl: stringType().optional(),
+    isFailedReason: booleanType().optional(),
+    isPrivate: booleanType().optional(),
+    parameterId: stringType().optional(),
+    text: stringType().optional(),
+    title: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      downloadUrl: "download_url",
+      isFailedReason: "is_failed_reason",
+      isPrivate: "is_private",
+      parameterId: "parameter_id"
+    });
+  });
+  ((VerificationResponseDetail$) => {
+    VerificationResponseDetail$.inboundSchema = VerificationResponseDetail$inboundSchema;
+    VerificationResponseDetail$.outboundSchema = VerificationResponseDetail$outboundSchema;
+  })(VerificationResponseDetail$ ||= {});
+});
+
+// src/sdk/models/shared/verificationrequest.ts
+var ProfileGender, ResponseStatus, ProfileGender$inboundSchema, ProfileGender$outboundSchema, ProfileGender$, ResponseStatus$inboundSchema, ResponseStatus$outboundSchema, ResponseStatus$, VerificationRequest$inboundSchema, VerificationRequest$outboundSchema, VerificationRequest$;
+var init_verificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_verificationaddress();
+  init_verificationparameterinput();
+  init_verificationresponsedetail();
+  ProfileGender = {
+    Male: "MALE",
+    Female: "FEMALE",
+    Intersex: "INTERSEX",
+    Trans: "TRANS",
+    NonBinary: "NON_BINARY"
+  };
+  ResponseStatus = {
+    Completed: "COMPLETED",
+    Failed: "FAILED",
+    Passed: "PASSED",
+    Pending: "PENDING"
+  };
+  ProfileGender$inboundSchema = unionType([
+    nativeEnumType(ProfileGender),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  ProfileGender$outboundSchema = unionType([
+    nativeEnumType(ProfileGender),
+    stringType().and(custom())
+  ]);
+  ((ProfileGender$) => {
+    ProfileGender$.inboundSchema = ProfileGender$inboundSchema;
+    ProfileGender$.outboundSchema = ProfileGender$outboundSchema;
+  })(ProfileGender$ ||= {});
+  ResponseStatus$inboundSchema = unionType([
+    nativeEnumType(ResponseStatus),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  ResponseStatus$outboundSchema = unionType([
+    nativeEnumType(ResponseStatus),
+    stringType().and(custom())
+  ]);
+  ((ResponseStatus$) => {
+    ResponseStatus$.inboundSchema = ResponseStatus$inboundSchema;
+    ResponseStatus$.outboundSchema = ResponseStatus$outboundSchema;
+  })(ResponseStatus$ ||= {});
+  VerificationRequest$inboundSchema = objectType({
+    candidate_id: stringType().optional(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    id: stringType().optional(),
+    package_id: stringType().optional(),
+    parameters: arrayType(VerificationParameterInput$inboundSchema).optional(),
+    profile_addresses: arrayType(VerificationAddress$inboundSchema).optional(),
+    profile_date_of_birth: stringType().optional(),
+    profile_emails: arrayType(stringType()).optional(),
+    profile_gender: ProfileGender$inboundSchema.optional(),
+    profile_ip_address: stringType().optional(),
+    profile_name: stringType().optional(),
+    profile_national_identifier: stringType().optional(),
+    profile_telephones: arrayType(stringType()).optional(),
+    raw: recordType(anyType()).optional(),
+    response_completed_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    response_details: arrayType(VerificationResponseDetail$inboundSchema).optional(),
+    response_download_urls: arrayType(stringType()).optional(),
+    response_expires_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    response_issued_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    response_redirect_url: stringType().optional(),
+    response_score: numberType().optional(),
+    response_source: stringType().optional(),
+    response_status: ResponseStatus$inboundSchema.optional(),
+    target_url: stringType().optional(),
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      candidate_id: "candidateId",
+      created_at: "createdAt",
+      package_id: "packageId",
+      profile_addresses: "profileAddresses",
+      profile_date_of_birth: "profileDateOfBirth",
+      profile_emails: "profileEmails",
+      profile_gender: "profileGender",
+      profile_ip_address: "profileIpAddress",
+      profile_name: "profileName",
+      profile_national_identifier: "profileNationalIdentifier",
+      profile_telephones: "profileTelephones",
+      response_completed_at: "responseCompletedAt",
+      response_details: "responseDetails",
+      response_download_urls: "responseDownloadUrls",
+      response_expires_at: "responseExpiresAt",
+      response_issued_at: "responseIssuedAt",
+      response_redirect_url: "responseRedirectUrl",
+      response_score: "responseScore",
+      response_source: "responseSource",
+      response_status: "responseStatus",
+      target_url: "targetUrl",
+      updated_at: "updatedAt"
+    });
+  });
+  VerificationRequest$outboundSchema = objectType({
+    candidateId: stringType().optional(),
+    createdAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    id: stringType().optional(),
+    packageId: stringType().optional(),
+    parameters: arrayType(VerificationParameterInput$outboundSchema).optional(),
+    profileAddresses: arrayType(VerificationAddress$outboundSchema).optional(),
+    profileDateOfBirth: stringType().optional(),
+    profileEmails: arrayType(stringType()).optional(),
+    profileGender: ProfileGender$outboundSchema.optional(),
+    profileIpAddress: stringType().optional(),
+    profileName: stringType().optional(),
+    profileNationalIdentifier: stringType().optional(),
+    profileTelephones: arrayType(stringType()).optional(),
+    raw: recordType(anyType()).optional(),
+    responseCompletedAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    responseDetails: arrayType(VerificationResponseDetail$outboundSchema).optional(),
+    responseDownloadUrls: arrayType(stringType()).optional(),
+    responseExpiresAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    responseIssuedAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    responseRedirectUrl: stringType().optional(),
+    responseScore: numberType().optional(),
+    responseSource: stringType().optional(),
+    responseStatus: ResponseStatus$outboundSchema.optional(),
+    targetUrl: stringType().optional(),
+    updatedAt: dateType().transform((v2) => v2.toISOString()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      candidateId: "candidate_id",
+      createdAt: "created_at",
+      packageId: "package_id",
+      profileAddresses: "profile_addresses",
+      profileDateOfBirth: "profile_date_of_birth",
+      profileEmails: "profile_emails",
+      profileGender: "profile_gender",
+      profileIpAddress: "profile_ip_address",
+      profileName: "profile_name",
+      profileNationalIdentifier: "profile_national_identifier",
+      profileTelephones: "profile_telephones",
+      responseCompletedAt: "response_completed_at",
+      responseDetails: "response_details",
+      responseDownloadUrls: "response_download_urls",
+      responseExpiresAt: "response_expires_at",
+      responseIssuedAt: "response_issued_at",
+      responseRedirectUrl: "response_redirect_url",
+      responseScore: "response_score",
+      responseSource: "response_source",
+      responseStatus: "response_status",
+      targetUrl: "target_url",
+      updatedAt: "updated_at"
+    });
+  });
+  ((VerificationRequest$) => {
+    VerificationRequest$.inboundSchema = VerificationRequest$inboundSchema;
+    VerificationRequest$.outboundSchema = VerificationRequest$outboundSchema;
+  })(VerificationRequest$ ||= {});
+});
+
 // src/sdk/models/shared/webhook.ts
 var DbType, Event, ObjectType, WebhookType, DbType$inboundSchema, DbType$outboundSchema, DbType$, Event$inboundSchema, Event$outboundSchema, Event$, ObjectType$inboundSchema, ObjectType$outboundSchema, ObjectType$, WebhookType$inboundSchema, WebhookType$outboundSchema, WebhookType$, Webhook$inboundSchema, Webhook$outboundSchema, Webhook$;
 var init_webhook = __esm(() => {
@@ -50218,6 +50677,8 @@ var init_webhook = __esm(() => {
     CommerceInventory: "commerce_inventory",
     CommerceLocation: "commerce_location",
     CommerceReview: "commerce_review",
+    VerificationPackage: "verification_package",
+    VerificationRequest: "verification_request",
     AtsActivity: "ats_activity",
     AtsApplication: "ats_application",
     AtsApplicationstatus: "ats_applicationstatus",
@@ -50668,6 +51129,13 @@ var init_shared2 = __esm(() => {
   init_ucrecordingmedia();
   init_ucrecordingtranscript();
   init_uctelephone();
+  init_verificationaddress();
+  init_verificationpackage();
+  init_verificationparameter();
+  init_verificationparameterinput();
+  init_verificationrequest();
+  init_verificationresponsedetail();
+  init_verificationtime();
   init_webhook();
 });
 
@@ -53331,6 +53799,40 @@ var init_createunifiedwebhook = __esm(() => {
   })(CreateUnifiedWebhookRequest$ ||= {});
 });
 
+// src/sdk/models/operations/createverificationrequest.ts
+var CreateVerificationRequestRequest$inboundSchema, CreateVerificationRequestRequest$outboundSchema, CreateVerificationRequestRequest$;
+var init_createverificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_shared2();
+  CreateVerificationRequestRequest$inboundSchema = objectType({
+    VerificationRequest: VerificationRequest$inboundSchema,
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      VerificationRequest: "verificationRequest",
+      connection_id: "connectionId"
+    });
+  });
+  CreateVerificationRequestRequest$outboundSchema = objectType({
+    verificationRequest: VerificationRequest$outboundSchema,
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      verificationRequest: "VerificationRequest",
+      connectionId: "connection_id"
+    });
+  });
+  ((CreateVerificationRequestRequest$) => {
+    CreateVerificationRequestRequest$.inboundSchema = CreateVerificationRequestRequest$inboundSchema;
+    CreateVerificationRequestRequest$.outboundSchema = CreateVerificationRequestRequest$outboundSchema;
+  })(CreateVerificationRequestRequest$ ||= {});
+});
+
 // src/sdk/models/operations/getaccountingaccount.ts
 var GetAccountingAccountRequest$inboundSchema, GetAccountingAccountRequest$outboundSchema, GetAccountingAccountRequest$;
 var init_getaccountingaccount = __esm(() => {
@@ -56040,6 +56542,68 @@ var init_getunifiedwebhook = __esm(() => {
   })(GetUnifiedWebhookRequest$ ||= {});
 });
 
+// src/sdk/models/operations/getverificationpackage.ts
+var GetVerificationPackageRequest$inboundSchema, GetVerificationPackageRequest$outboundSchema, GetVerificationPackageRequest$;
+var init_getverificationpackage = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetVerificationPackageRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId"
+    });
+  });
+  GetVerificationPackageRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id"
+    });
+  });
+  ((GetVerificationPackageRequest$) => {
+    GetVerificationPackageRequest$.inboundSchema = GetVerificationPackageRequest$inboundSchema;
+    GetVerificationPackageRequest$.outboundSchema = GetVerificationPackageRequest$outboundSchema;
+  })(GetVerificationPackageRequest$ ||= {});
+});
+
+// src/sdk/models/operations/getverificationrequest.ts
+var GetVerificationRequestRequest$inboundSchema, GetVerificationRequestRequest$outboundSchema, GetVerificationRequestRequest$;
+var init_getverificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetVerificationRequestRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId"
+    });
+  });
+  GetVerificationRequestRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id"
+    });
+  });
+  ((GetVerificationRequestRequest$) => {
+    GetVerificationRequestRequest$.inboundSchema = GetVerificationRequestRequest$inboundSchema;
+    GetVerificationRequestRequest$.outboundSchema = GetVerificationRequestRequest$outboundSchema;
+  })(GetVerificationRequestRequest$ ||= {});
+});
+
 // src/sdk/models/operations/listaccountingaccounts.ts
 var ListAccountingAccountsRequest$inboundSchema, ListAccountingAccountsRequest$outboundSchema, ListAccountingAccountsRequest$;
 var init_listaccountingaccounts = __esm(() => {
@@ -56093,7 +56657,9 @@ var init_listaccountingbalancesheets = __esm(() => {
   init_esm();
   init_primitives();
   ListAccountingBalancesheetsRequest$inboundSchema = objectType({
+    category_id: stringType().optional(),
     connection_id: stringType(),
+    contact_id: stringType().optional(),
     end_le: stringType().optional(),
     fields: arrayType(stringType()).optional(),
     limit: numberType().optional(),
@@ -56106,14 +56672,18 @@ var init_listaccountingbalancesheets = __esm(() => {
     updated_gte: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
+      category_id: "categoryId",
       connection_id: "connectionId",
+      contact_id: "contactId",
       end_le: "endLe",
       start_gte: "startGte",
       updated_gte: "updatedGte"
     });
   });
   ListAccountingBalancesheetsRequest$outboundSchema = objectType({
+    categoryId: stringType().optional(),
     connectionId: stringType(),
+    contactId: stringType().optional(),
     endLe: stringType().optional(),
     fields: arrayType(stringType()).optional(),
     limit: numberType().optional(),
@@ -56126,7 +56696,9 @@ var init_listaccountingbalancesheets = __esm(() => {
     updatedGte: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
+      categoryId: "category_id",
       connectionId: "connection_id",
+      contactId: "contact_id",
       endLe: "end_le",
       startGte: "start_gte",
       updatedGte: "updated_gte"
@@ -56534,7 +57106,9 @@ var init_listaccountingprofitlosses = __esm(() => {
   init_esm();
   init_primitives();
   ListAccountingProfitlossesRequest$inboundSchema = objectType({
+    category_id: stringType().optional(),
     connection_id: stringType(),
+    contact_id: stringType().optional(),
     end_le: stringType().optional(),
     fields: arrayType(stringType()).optional(),
     limit: numberType().optional(),
@@ -56547,14 +57121,18 @@ var init_listaccountingprofitlosses = __esm(() => {
     updated_gte: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
+      category_id: "categoryId",
       connection_id: "connectionId",
+      contact_id: "contactId",
       end_le: "endLe",
       start_gte: "startGte",
       updated_gte: "updatedGte"
     });
   });
   ListAccountingProfitlossesRequest$outboundSchema = objectType({
+    categoryId: stringType().optional(),
     connectionId: stringType(),
+    contactId: stringType().optional(),
     endLe: stringType().optional(),
     fields: arrayType(stringType()).optional(),
     limit: numberType().optional(),
@@ -56567,7 +57145,9 @@ var init_listaccountingprofitlosses = __esm(() => {
     updatedGte: stringType().optional()
   }).transform((v2) => {
     return remap(v2, {
+      categoryId: "category_id",
       connectionId: "connection_id",
+      contactId: "contact_id",
       endLe: "end_le",
       startGte: "start_gte",
       updatedGte: "updated_gte"
@@ -60622,7 +61202,8 @@ var init_listunifiedconnections = __esm(() => {
     Lms: "lms",
     Repo: "repo",
     Metadata: "metadata",
-    Calendar: "calendar"
+    Calendar: "calendar",
+    Verification: "verification"
   };
   Categories$inboundSchema = nativeEnumType(Categories);
   Categories$outboundSchema = Categories$inboundSchema;
@@ -60693,7 +61274,8 @@ var init_listunifiedintegrations = __esm(() => {
     Lms: "lms",
     Repo: "repo",
     Metadata: "metadata",
-    Calendar: "calendar"
+    Calendar: "calendar",
+    Verification: "verification"
   };
   ListUnifiedIntegrationsQueryParamCategories$inboundSchema = nativeEnumType(ListUnifiedIntegrationsQueryParamCategories);
   ListUnifiedIntegrationsQueryParamCategories$outboundSchema = ListUnifiedIntegrationsQueryParamCategories$inboundSchema;
@@ -60762,7 +61344,8 @@ var init_listunifiedintegrationworkspaces = __esm(() => {
     Lms: "lms",
     Repo: "repo",
     Metadata: "metadata",
-    Calendar: "calendar"
+    Calendar: "calendar",
+    Verification: "verification"
   };
   QueryParamCategories$inboundSchema = nativeEnumType(QueryParamCategories);
   QueryParamCategories$outboundSchema = QueryParamCategories$inboundSchema;
@@ -60888,6 +61471,100 @@ var init_listunifiedwebhooks = __esm(() => {
   })(ListUnifiedWebhooksRequest$ ||= {});
 });
 
+// src/sdk/models/operations/listverificationpackages.ts
+var ListVerificationPackagesRequest$inboundSchema, ListVerificationPackagesRequest$outboundSchema, ListVerificationPackagesRequest$;
+var init_listverificationpackages = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListVerificationPackagesRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    updated_gte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId",
+      updated_gte: "updatedGte"
+    });
+  });
+  ListVerificationPackagesRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    updatedGte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id",
+      updatedGte: "updated_gte"
+    });
+  });
+  ((ListVerificationPackagesRequest$) => {
+    ListVerificationPackagesRequest$.inboundSchema = ListVerificationPackagesRequest$inboundSchema;
+    ListVerificationPackagesRequest$.outboundSchema = ListVerificationPackagesRequest$outboundSchema;
+  })(ListVerificationPackagesRequest$ ||= {});
+});
+
+// src/sdk/models/operations/listverificationrequests.ts
+var ListVerificationRequestsRequest$inboundSchema, ListVerificationRequestsRequest$outboundSchema, ListVerificationRequestsRequest$;
+var init_listverificationrequests = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListVerificationRequestsRequest$inboundSchema = objectType({
+    candidate_id: stringType().optional(),
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    package_id: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    updated_gte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      candidate_id: "candidateId",
+      connection_id: "connectionId",
+      package_id: "packageId",
+      updated_gte: "updatedGte"
+    });
+  });
+  ListVerificationRequestsRequest$outboundSchema = objectType({
+    candidateId: stringType().optional(),
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    packageId: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    updatedGte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      candidateId: "candidate_id",
+      connectionId: "connection_id",
+      packageId: "package_id",
+      updatedGte: "updated_gte"
+    });
+  });
+  ((ListVerificationRequestsRequest$) => {
+    ListVerificationRequestsRequest$.inboundSchema = ListVerificationRequestsRequest$inboundSchema;
+    ListVerificationRequestsRequest$.outboundSchema = ListVerificationRequestsRequest$outboundSchema;
+  })(ListVerificationRequestsRequest$ ||= {});
+});
+
 // src/sdk/models/operations/patchaccountingaccount.ts
 var PatchAccountingAccountRequest$inboundSchema, PatchAccountingAccountRequest$outboundSchema, PatchAccountingAccountRequest$;
 var init_patchaccountingaccount = __esm(() => {
@@ -63707,6 +64384,42 @@ var init_patchunifiedwebhooktrigger = __esm(() => {
   })(PatchUnifiedWebhookTriggerResponse$ ||= {});
 });
 
+// src/sdk/models/operations/patchverificationrequest.ts
+var PatchVerificationRequestRequest$inboundSchema, PatchVerificationRequestRequest$outboundSchema, PatchVerificationRequestRequest$;
+var init_patchverificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_shared2();
+  PatchVerificationRequestRequest$inboundSchema = objectType({
+    VerificationRequest: VerificationRequest$inboundSchema,
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      VerificationRequest: "verificationRequest",
+      connection_id: "connectionId"
+    });
+  });
+  PatchVerificationRequestRequest$outboundSchema = objectType({
+    verificationRequest: VerificationRequest$outboundSchema,
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      verificationRequest: "VerificationRequest",
+      connectionId: "connection_id"
+    });
+  });
+  ((PatchVerificationRequestRequest$) => {
+    PatchVerificationRequestRequest$.inboundSchema = PatchVerificationRequestRequest$inboundSchema;
+    PatchVerificationRequestRequest$.outboundSchema = PatchVerificationRequestRequest$outboundSchema;
+  })(PatchVerificationRequestRequest$ ||= {});
+});
+
 // src/sdk/models/operations/removeaccountingaccount.ts
 var RemoveAccountingAccountRequest$inboundSchema, RemoveAccountingAccountRequest$outboundSchema, RemoveAccountingAccountRequest$, RemoveAccountingAccountResponse$inboundSchema, RemoveAccountingAccountResponse$outboundSchema, RemoveAccountingAccountResponse$;
 var init_removeaccountingaccount = __esm(() => {
@@ -67053,6 +67766,51 @@ var init_removeunifiedwebhook = __esm(() => {
   })(RemoveUnifiedWebhookResponse$ ||= {});
 });
 
+// src/sdk/models/operations/removeverificationrequest.ts
+var RemoveVerificationRequestRequest$inboundSchema, RemoveVerificationRequestRequest$outboundSchema, RemoveVerificationRequestRequest$, RemoveVerificationRequestResponse$inboundSchema, RemoveVerificationRequestResponse$outboundSchema, RemoveVerificationRequestResponse$;
+var init_removeverificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  RemoveVerificationRequestRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId"
+    });
+  });
+  RemoveVerificationRequestRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id"
+    });
+  });
+  ((RemoveVerificationRequestRequest$) => {
+    RemoveVerificationRequestRequest$.inboundSchema = RemoveVerificationRequestRequest$inboundSchema;
+    RemoveVerificationRequestRequest$.outboundSchema = RemoveVerificationRequestRequest$outboundSchema;
+  })(RemoveVerificationRequestRequest$ ||= {});
+  RemoveVerificationRequestResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers"
+    });
+  });
+  RemoveVerificationRequestResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers"
+    });
+  });
+  ((RemoveVerificationRequestResponse$) => {
+    RemoveVerificationRequestResponse$.inboundSchema = RemoveVerificationRequestResponse$inboundSchema;
+    RemoveVerificationRequestResponse$.outboundSchema = RemoveVerificationRequestResponse$outboundSchema;
+  })(RemoveVerificationRequestResponse$ ||= {});
+});
+
 // src/sdk/models/operations/updateaccountingaccount.ts
 var UpdateAccountingAccountRequest$inboundSchema, UpdateAccountingAccountRequest$outboundSchema, UpdateAccountingAccountRequest$;
 var init_updateaccountingaccount = __esm(() => {
@@ -69872,6 +70630,42 @@ var init_updateunifiedwebhooktrigger = __esm(() => {
   })(UpdateUnifiedWebhookTriggerResponse$ ||= {});
 });
 
+// src/sdk/models/operations/updateverificationrequest.ts
+var UpdateVerificationRequestRequest$inboundSchema, UpdateVerificationRequestRequest$outboundSchema, UpdateVerificationRequestRequest$;
+var init_updateverificationrequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_shared2();
+  UpdateVerificationRequestRequest$inboundSchema = objectType({
+    VerificationRequest: VerificationRequest$inboundSchema,
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      VerificationRequest: "verificationRequest",
+      connection_id: "connectionId"
+    });
+  });
+  UpdateVerificationRequestRequest$outboundSchema = objectType({
+    verificationRequest: VerificationRequest$outboundSchema,
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      verificationRequest: "VerificationRequest",
+      connectionId: "connection_id"
+    });
+  });
+  ((UpdateVerificationRequestRequest$) => {
+    UpdateVerificationRequestRequest$.inboundSchema = UpdateVerificationRequestRequest$inboundSchema;
+    UpdateVerificationRequestRequest$.outboundSchema = UpdateVerificationRequestRequest$outboundSchema;
+  })(UpdateVerificationRequestRequest$ ||= {});
+});
+
 // src/sdk/models/operations/index.ts
 var init_operations = __esm(() => {
   init_createaccountingaccount();
@@ -69949,6 +70743,7 @@ var init_operations = __esm(() => {
   init_createuccontact();
   init_createucrecording();
   init_createunifiedwebhook();
+  init_createverificationrequest();
   init_getaccountingaccount();
   init_getaccountingbalancesheet();
   init_getaccountingbill();
@@ -70037,6 +70832,8 @@ var init_operations = __esm(() => {
   init_getunifiedintegrationauth();
   init_getunifiedintegrationlogin();
   init_getunifiedwebhook();
+  init_getverificationpackage();
+  init_getverificationrequest();
   init_listaccountingaccounts();
   init_listaccountingbalancesheets();
   init_listaccountingbills();
@@ -70133,6 +70930,8 @@ var init_operations = __esm(() => {
   init_listunifiedintegrationworkspaces();
   init_listunifiedissues();
   init_listunifiedwebhooks();
+  init_listverificationpackages();
+  init_listverificationrequests();
   init_patchaccountingaccount();
   init_patchaccountingbill();
   init_patchaccountingcategory();
@@ -70209,6 +71008,7 @@ var init_operations = __esm(() => {
   init_patchunifiedconnection();
   init_patchunifiedwebhook();
   init_patchunifiedwebhooktrigger();
+  init_patchverificationrequest();
   init_removeaccountingaccount();
   init_removeaccountingbill();
   init_removeaccountingcategory();
@@ -70283,6 +71083,7 @@ var init_operations = __esm(() => {
   init_removeucrecording();
   init_removeunifiedconnection();
   init_removeunifiedwebhook();
+  init_removeverificationrequest();
   init_updateaccountingaccount();
   init_updateaccountingbill();
   init_updateaccountingcategory();
@@ -70359,6 +71160,7 @@ var init_operations = __esm(() => {
   init_updateunifiedconnection();
   init_updateunifiedwebhook();
   init_updateunifiedwebhooktrigger();
+  init_updateverificationrequest();
 });
 
 // src/sdk/types/async.ts
@@ -73714,6 +74516,8 @@ async function $do31(client, request, options) {
   };
   const path = pathToFunc("/accounting/{connection_id}/balancesheet")(pathParams);
   const query = encodeFormQuery({
+    category_id: payload.category_id,
+    contact_id: payload.contact_id,
     end_le: payload.end_le,
     fields: payload.fields,
     limit: payload.limit,
@@ -74755,6 +75559,8 @@ async function $do40(client, request, options) {
   };
   const path = pathToFunc("/accounting/{connection_id}/profitloss")(pathParams);
   const query = encodeFormQuery({
+    category_id: payload.category_id,
+    contact_id: payload.contact_id,
     end_le: payload.end_le,
     fields: payload.fields,
     limit: payload.limit,
@@ -124306,11 +125112,908 @@ var init_unifiedUpdateUnifiedWebhookTrigger2 = __esm(() => {
   };
 });
 
+// src/funcs/verificationCreateVerificationRequest.ts
+function verificationCreateVerificationRequest(client, request, options) {
+  return new APIPromise($do487(client, request, options));
+}
+async function $do487(client, request, options) {
+  const parsed = safeParse(request, (value) => CreateVerificationRequestRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.VerificationRequest, {
+    explode: true
+  });
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createVerificationRequest",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, VerificationRequest$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationCreateVerificationRequest = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationCreateVerificationRequest.ts
+var args487, tool$verificationCreateVerificationRequest;
+var init_verificationCreateVerificationRequest2 = __esm(() => {
+  init_verificationCreateVerificationRequest();
+  init_operations();
+  init_tools();
+  args487 = {
+    request: CreateVerificationRequestRequest$inboundSchema
+  };
+  tool$verificationCreateVerificationRequest = {
+    name: "verification-create-verification-request",
+    description: `Create a request`,
+    args: args487,
+    tool: async (client, args488, ctx) => {
+      const [result, apiCall] = await verificationCreateVerificationRequest(client, args488.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationGetVerificationPackage.ts
+function verificationGetVerificationPackage(client, request, options) {
+  return new APIPromise($do488(client, request, options));
+}
+async function $do488(client, request, options) {
+  const parsed = safeParse(request, (value) => GetVerificationPackageRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/package/{id}")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getVerificationPackage",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, VerificationPackage$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationGetVerificationPackage = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationGetVerificationPackage.ts
+var args488, tool$verificationGetVerificationPackage;
+var init_verificationGetVerificationPackage2 = __esm(() => {
+  init_verificationGetVerificationPackage();
+  init_operations();
+  init_tools();
+  args488 = {
+    request: GetVerificationPackageRequest$inboundSchema
+  };
+  tool$verificationGetVerificationPackage = {
+    name: "verification-get-verification-package",
+    description: `Retrieve a package`,
+    args: args488,
+    tool: async (client, args489, ctx) => {
+      const [result, apiCall] = await verificationGetVerificationPackage(client, args489.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationGetVerificationRequest.ts
+function verificationGetVerificationRequest(client, request, options) {
+  return new APIPromise($do489(client, request, options));
+}
+async function $do489(client, request, options) {
+  const parsed = safeParse(request, (value) => GetVerificationRequestRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request/{id}")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getVerificationRequest",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, VerificationRequest$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationGetVerificationRequest = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationGetVerificationRequest.ts
+var args489, tool$verificationGetVerificationRequest;
+var init_verificationGetVerificationRequest2 = __esm(() => {
+  init_verificationGetVerificationRequest();
+  init_operations();
+  init_tools();
+  args489 = {
+    request: GetVerificationRequestRequest$inboundSchema
+  };
+  tool$verificationGetVerificationRequest = {
+    name: "verification-get-verification-request",
+    description: `Retrieve a request`,
+    args: args489,
+    tool: async (client, args490, ctx) => {
+      const [result, apiCall] = await verificationGetVerificationRequest(client, args490.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationListVerificationPackages.ts
+function verificationListVerificationPackages(client, request, options) {
+  return new APIPromise($do490(client, request, options));
+}
+async function $do490(client, request, options) {
+  const parsed = safeParse(request, (value) => ListVerificationPackagesRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/package")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    limit: payload.limit,
+    offset: payload.offset,
+    order: payload.order,
+    query: payload.query,
+    raw: payload.raw,
+    sort: payload.sort,
+    updated_gte: payload.updated_gte
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listVerificationPackages",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, arrayType(VerificationPackage$inboundSchema)), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationListVerificationPackages = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationListVerificationPackages.ts
+var args490, tool$verificationListVerificationPackages;
+var init_verificationListVerificationPackages2 = __esm(() => {
+  init_verificationListVerificationPackages();
+  init_operations();
+  init_tools();
+  args490 = {
+    request: ListVerificationPackagesRequest$inboundSchema
+  };
+  tool$verificationListVerificationPackages = {
+    name: "verification-list-verification-packages",
+    description: `List all packages`,
+    args: args490,
+    tool: async (client, args491, ctx) => {
+      const [result, apiCall] = await verificationListVerificationPackages(client, args491.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationListVerificationRequests.ts
+function verificationListVerificationRequests(client, request, options) {
+  return new APIPromise($do491(client, request, options));
+}
+async function $do491(client, request, options) {
+  const parsed = safeParse(request, (value) => ListVerificationRequestsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request")(pathParams);
+  const query = encodeFormQuery({
+    candidate_id: payload.candidate_id,
+    fields: payload.fields,
+    limit: payload.limit,
+    offset: payload.offset,
+    order: payload.order,
+    package_id: payload.package_id,
+    query: payload.query,
+    raw: payload.raw,
+    sort: payload.sort,
+    updated_gte: payload.updated_gte
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listVerificationRequests",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, arrayType(VerificationRequest$inboundSchema)), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationListVerificationRequests = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationListVerificationRequests.ts
+var args491, tool$verificationListVerificationRequests;
+var init_verificationListVerificationRequests2 = __esm(() => {
+  init_verificationListVerificationRequests();
+  init_operations();
+  init_tools();
+  args491 = {
+    request: ListVerificationRequestsRequest$inboundSchema
+  };
+  tool$verificationListVerificationRequests = {
+    name: "verification-list-verification-requests",
+    description: `List all requests`,
+    args: args491,
+    tool: async (client, args492, ctx) => {
+      const [result, apiCall] = await verificationListVerificationRequests(client, args492.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationPatchVerificationRequest.ts
+function verificationPatchVerificationRequest(client, request, options) {
+  return new APIPromise($do492(client, request, options));
+}
+async function $do492(client, request, options) {
+  const parsed = safeParse(request, (value) => PatchVerificationRequestRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.VerificationRequest, {
+    explode: true
+  });
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request/{id}")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "patchVerificationRequest",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, VerificationRequest$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationPatchVerificationRequest = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationPatchVerificationRequest.ts
+var args492, tool$verificationPatchVerificationRequest;
+var init_verificationPatchVerificationRequest2 = __esm(() => {
+  init_verificationPatchVerificationRequest();
+  init_operations();
+  init_tools();
+  args492 = {
+    request: PatchVerificationRequestRequest$inboundSchema
+  };
+  tool$verificationPatchVerificationRequest = {
+    name: "verification-patch-verification-request",
+    description: `Update a request`,
+    args: args492,
+    tool: async (client, args493, ctx) => {
+      const [result, apiCall] = await verificationPatchVerificationRequest(client, args493.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationRemoveVerificationRequest.ts
+function verificationRemoveVerificationRequest(client, request, options) {
+  return new APIPromise($do493(client, request, options));
+}
+async function $do493(client, request, options) {
+  const parsed = safeParse(request, (value) => RemoveVerificationRequestRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request/{id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "*/*"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "removeVerificationRequest",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(nil(200, RemoveVerificationRequestResponse$inboundSchema.optional()), fail("4XX"), fail("5XX"), nil("default", RemoveVerificationRequestResponse$inboundSchema.optional(), { hdrs: true }))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationRemoveVerificationRequest = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationRemoveVerificationRequest.ts
+var args493, tool$verificationRemoveVerificationRequest;
+var init_verificationRemoveVerificationRequest2 = __esm(() => {
+  init_verificationRemoveVerificationRequest();
+  init_operations();
+  init_tools();
+  args493 = {
+    request: RemoveVerificationRequestRequest$inboundSchema
+  };
+  tool$verificationRemoveVerificationRequest = {
+    name: "verification-remove-verification-request",
+    description: `Remove a request`,
+    args: args493,
+    tool: async (client, args494, ctx) => {
+      const [result, apiCall] = await verificationRemoveVerificationRequest(client, args494.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(undefined, apiCall);
+    }
+  };
+});
+
+// src/funcs/verificationUpdateVerificationRequest.ts
+function verificationUpdateVerificationRequest(client, request, options) {
+  return new APIPromise($do494(client, request, options));
+}
+async function $do494(client, request, options) {
+  const parsed = safeParse(request, (value) => UpdateVerificationRequestRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.VerificationRequest, {
+    explode: true
+  });
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/verification/{connection_id}/request/{id}")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "updateVerificationRequest",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PUT",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, VerificationRequest$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_verificationUpdateVerificationRequest = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/verificationUpdateVerificationRequest.ts
+var args494, tool$verificationUpdateVerificationRequest;
+var init_verificationUpdateVerificationRequest2 = __esm(() => {
+  init_verificationUpdateVerificationRequest();
+  init_operations();
+  init_tools();
+  args494 = {
+    request: UpdateVerificationRequestRequest$inboundSchema
+  };
+  tool$verificationUpdateVerificationRequest = {
+    name: "verification-update-verification-request",
+    description: `Update a request`,
+    args: args494,
+    tool: async (client, args495, ctx) => {
+      const [result, apiCall] = await verificationUpdateVerificationRequest(client, args495.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
 // src/mcp-server/server.ts
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "UnifiedTo",
-    version: "2.73.17"
+    version: "2.73.19"
   });
   const client = new UnifiedToCore({
     security: deps.security,
@@ -124810,6 +126513,14 @@ function createMCPServer(deps) {
   tool(tool$unifiedUpdateUnifiedWebhook);
   tool(tool$unifiedUpdateUnifiedWebhookTrigger);
   tool(tool$authGetUnifiedIntegrationLogin);
+  tool(tool$verificationCreateVerificationRequest);
+  tool(tool$verificationGetVerificationPackage);
+  tool(tool$verificationGetVerificationRequest);
+  tool(tool$verificationListVerificationPackages);
+  tool(tool$verificationListVerificationRequests);
+  tool(tool$verificationPatchVerificationRequest);
+  tool(tool$verificationRemoveVerificationRequest);
+  tool(tool$verificationUpdateVerificationRequest);
   return server;
 }
 var init_server2 = __esm(() => {
@@ -125303,6 +127014,14 @@ var init_server2 = __esm(() => {
   init_unifiedUpdateUnifiedConnection2();
   init_unifiedUpdateUnifiedWebhook2();
   init_unifiedUpdateUnifiedWebhookTrigger2();
+  init_verificationCreateVerificationRequest2();
+  init_verificationGetVerificationPackage2();
+  init_verificationGetVerificationRequest2();
+  init_verificationListVerificationPackages2();
+  init_verificationListVerificationRequests2();
+  init_verificationPatchVerificationRequest2();
+  init_verificationRemoveVerificationRequest2();
+  init_verificationUpdateVerificationRequest2();
 });
 
 // src/mcp-server/cli/start/impl.ts
@@ -126477,7 +128196,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "2.73.17"
+    currentVersion: "2.73.19"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -126485,5 +128204,5 @@ export {
   app
 };
 
-//# debugId=BA55FF210F1727DA64756E2164756E21
+//# debugId=2E9AA79EB9CE254264756E2164756E21
 //# sourceMappingURL=mcp-server.js.map