lancer-shared 1.2.139 → 1.2.141

package/dist/bundle.cjs.js

@@ -6689,6 +6689,10 @@ const bidderAccountProviderDisplayMap = {
     'user-provided': 'User Provided',
 };
 
+const planSlugToNameMap = {
+    "lancer-unlimited-launch-offer": "Lancer Unlimited - Launch Offer",
+};
+
 var util;
 (function (util) {
     util.assertEqual = (val) => val;
@@ -12743,513 +12747,197 @@ const generateLeadCountsRequestSchema = z.object({
     campaignId: z.string().optional(),
 });
 
-const bidPayloadProposalDataSchema = z.object({
-    coverLetter: z.string(),
-    questionAnswerPairs: questionAnswerPairSchema.array().nullable(),
-    boostingEnabled: z.boolean(),
-    maximumBoost: z.number().nullable(),
+const usageEventTypeEnum = z.enum([
+    'suitabilityComplete',
+    'proposalComplete',
+    'biddingComplete',
+]);
+const usageEventMetadataSchema = objectType({
+    campaignId: stringType().nullable(),
+    userId: stringType().nullable(),
+    stripeSubscriptionId: stringType().nullable(),
+    planId: stringType().nullable(),
 });
-const freelancerBidProposalDataSchema = bidPayloadProposalDataSchema;
-const agencyBidProposalDataSchema = bidPayloadProposalDataSchema.extend({
-    agencyName: z.string(),
-    contractorName: z.string(),
-    specializedProfile: z.string().nullable(),
+const usageEventSchema = objectType({
+    organizationId: stringType(),
+    typeId: usageEventTypeEnum,
+    timestamp: numberType(),
+    metadata: usageEventMetadataSchema,
 });
-const bidPayloadSchema = z.object({
-    organizationId: z.string(),
-    campaignId: z.string(),
-    lead: leadSchema,
-    jobUrl: z.string(),
-    username: z.string(),
-    password: z.string(),
+
+const billingStripeMetadataSchema = objectType({
+    customer: objectType({ id: stringType().nullable() }),
 });
-const agencyBidPayloadSchema = bidPayloadSchema.extend({
-    proposalData: agencyBidProposalDataSchema,
+const billingSchema = objectType({
+    savedCard: booleanType(),
+    stripe: billingStripeMetadataSchema,
 });
-const freelancerBidPayloadSchema = bidPayloadSchema.extend({
-    proposalData: freelancerBidProposalDataSchema,
+
+const subscriptionStatusEnum = z.enum([
+    "active",
+    "trialing",
+    "cancelled",
+    "paused",
+    "payment_processing",
+    "payment_pending",
+    "payment_failed",
+]);
+const subscriptionSourceEnum = z.enum(["stripe", "manual"]);
+const subscriptionStripeMetadataItemSchema = objectType({
+    id: stringType(),
+    price: objectType({
+        id: stringType(),
+    }),
 });
-const bidDtoSchema = z.object({
-    organizationId: z.string(),
-    campaignId: z.string(),
-    leadId: z.string(),
+const subscriptionStripeMetadataSchema = objectType({
+    id: stringType(),
+    items: arrayType(subscriptionStripeMetadataItemSchema),
+    invoice: objectType({
+        id: stringType(),
+        hosted_invoice_url: stringType().nullable(),
+    }),
+});
+const subscriptionSchema = objectType({
+    planId: stringType(),
+    pendingPlanId: stringType().nullable(),
+    status: subscriptionStatusEnum,
+    startedAt: numberType(),
+    currentPeriodEnd: numberType(),
+    stripe: subscriptionStripeMetadataSchema,
+    source: subscriptionSourceEnum,
+    usage: recordType(usageEventTypeEnum, numberType()),
 });
 
-const bidSuccessSchema = z.object({
-    status: z.literal("success"),
-    biddingAmount: z.number(),
-    boosted: z.boolean(),
-    boostingAmount: z.number(),
+const coverLetterTemplateSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    template: z.string(),
+    instructions: z.string(),
 });
-const bidFailedSchema = z.object({
-    status: z.literal("failed"),
-    errorMessage: z.string(),
+const createCoverLetterTemplateSchema = coverLetterTemplateSchema.pick({
+    name: true,
+    template: true,
+    instructions: true,
 });
 
-class CloudflareChallengeFailedException extends Error {
-    code = 'CLOUDFLARE_CHALLENGE_FAILED_EXCEPTION';
-    constructor(url, errorMessage) {
-        super(`Cloudflare challenge failed for ${url}\n\n ${errorMessage}`);
-    }
-}
-const cloudflareProtectionFailure = (url, errorMessage) => new CloudflareChallengeFailedException(url, errorMessage);
-
-class DeleteMultiloginProfileException extends Error {
-    code = 'DELETE_MULTILOGIN_PROFILE_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const deleteMultiloginProfileException = (message) => new DeleteMultiloginProfileException(message);
+const organizationMemberRoleEnum = z.enum(["admin", "member"]);
+const organizationMemberSchema = objectType({
+    role: organizationMemberRoleEnum,
+    joinedAt: numberType(),
+    invitedBy: stringType(),
+});
 
-class DropdownOptionNotPresentException extends Error {
-    code = 'DROPDOWN_OPTION_NOT_PRESENT_EXCEPTION';
-    constructor(selector, option) {
-        super(`${selector} does not contain option ${option}`);
-    }
-}
-function dropdownOptionNotPresentException(selector, option) {
-    return new DropdownOptionNotPresentException(selector, option);
-}
+const onboardingProgressSchema = z.object({
+    profileSetup: z.boolean(),
+    campaignCreated: z.boolean(),
+    filtersAdded: z.boolean(),
+    automationEnabled: z.boolean(),
+    startCampaign: z.boolean(),
+});
 
-class ElementNotClickableException extends Error {
-    code = 'ELEMENT_NOT_CLICKABLE_EXCEPTION';
-    constructor(context, message) {
-        super(`${context} is not clickable: ${message}`);
-    }
-}
-function elementNotClickableException(elementInfo, message) {
-    return new ElementNotClickableException(JSON.stringify(elementInfo), message);
-}
+const organizationTypeSchema = z.enum(["agency", "freelancer"]);
+const organizationTierEnum = z.enum(["free", "premium"]);
+const limitsSchema = objectType({
+    monthlyCredits: numberType(),
+    usedCredits: numberType(),
+    extraCredits: numberType(),
+});
+const oneTimePaymentSchema = z.object({
+    paidAt: z.number().optional(),
+    amount: z.number().optional(),
+    currency: z.string().optional(),
+    status: z.string(),
+    paymentIntentId: z.string().optional(),
+    error: z.string().optional(),
+});
+const oneTimePaymentsSchema = z.object({
+    usBidderAccountPayment: oneTimePaymentSchema.optional(),
+});
+const organizationSchema = objectType({
+    id: stringType(),
+    name: stringType(),
+    type: organizationTypeSchema,
+    associatedBidders: z.array(stringType()).nullable(),
+    subscription: subscriptionSchema.nullable(),
+    active: booleanType(),
+    limits: limitsSchema,
+    billing: billingSchema.nullable(),
+    lastBidTime: numberType().nullable(),
+    nextScheduledBidTime: numberType().nullable(),
+    createdAt: numberType(),
+    updatedAt: numberType(),
+    openRouterApiKey: stringType().nullable(),
+    appTrialEndsAt: numberType().nullable(),
+    oneTimePayments: oneTimePaymentsSchema.optional(),
+});
+const organizationUpdateSchema = objectType({ planId: stringType() });
+const caseStudySchema = objectType({
+    id: stringType(),
+    title: stringType(),
+    description: stringType(),
+});
+z.object({
+    type: z.enum(["freelancer", "agency"]),
+    name: z.string(),
+    summary: z.string(),
+    coreServices: z.string(),
+    toolsSkillsTechnologies: z.string(),
+    approach: z.string(),
+    icp: z.string(),
+    projectsTheyAvoid: z.string(),
+    spokenLanguages: z.string(),
+    agencyInfo: z.object({
+        location: z.array(z.string()),
+        website: z.string().url(),
+        teamSize: z.number(),
+    }),
+    caseStudies: z.array(caseStudySchema),
+});
+const createOrganizationSchema = organizationSchema.pick({
+    name: true,
+    type: true,
+});
+const trackUsageEventTypeEnum = z.enum([
+    "suitabilityComplete",
+    "proposalComplete",
+    "biddingComplete",
+]);
+const trackUsagePayloadSchema = objectType({
+    event: usageEventTypeEnum,
+    campaignId: stringType().nullish(),
+});
+const questionRulesSchema = objectType({
+    question: stringType(),
+    answer: stringType(),
+    category: stringType(),
+});
+const aiConfigSchema = objectType({
+    questionHandling: z.string().nullable(),
+    questionRules: arrayType(questionRulesSchema).nullable(),
+    disqualifierRules: z.string().nullable(),
+    userInstructions: z.string().nullable(),
+});
+const notificationConfigSchema = objectType({
+    emailEnabled: booleanType(),
+    discordWebhookUrl: stringType().nullable(),
+    slackWebhookUrl: stringType().nullable(),
+});
+const organizationSettingsSchema = objectType({
+    aiConfig: aiConfigSchema,
+});
+const subscribePayloadSchema = objectType({
+    planId: stringType().min(1, "Plan id is required."),
+    paymentMethodId: stringType().min(1, "Payment method is required."),
+    toltReferral: stringType().optional(),
+    couponCode: stringType().nullish(),
+});
 
-class EvaluateElementException extends Error {
-    code = 'EVALUATE_ELEMENT_EXCEPTION';
-    constructor(element, message) {
-        super(`Element evaluation for ${JSON.stringify(element)} failed: ${message}`);
-    }
-}
-function evaluateElementException(element, message) {
-    return new EvaluateElementException(element, message);
-}
-
-class EvaluateFunctionException extends Error {
-    code = 'EVALUATE_FUNCTION_EXCEPTION';
-    constructor(fn, args, message) {
-        super(`Evaluation function ${fn.toString()} failed with selectors: ${args} \n\n Error Message: ${message}`);
-    }
-}
-function evaluateFunctionException(fn, args, message) {
-    return new EvaluateFunctionException(fn, args, message);
-}
-
-class GetMultiloginBrowserException extends Error {
-    code = 'GET_MULTILOGIN_BROWSER_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const getMultiloginBrowserException = (message) => new GetMultiloginBrowserException(message);
-
-class IncorrectSecurityQuestionAnswerException extends Error {
-    code = 'INCORRECT_SECURITY_QUESTION_ANSWER_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const incorrectSecurityQuestionAnswerException = (message) => new IncorrectSecurityQuestionAnswerException(message);
-
-class InitBrowserException extends Error {
-    code = 'INIT_BROWSER_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const initBrowserException = (message) => new InitBrowserException(message);
-
-class InsufficientConnectsException extends Error {
-    code = 'INSUFFICIENT_CONNECTS_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const insufficientConnectsException = (message) => new InsufficientConnectsException(message);
-
-class InvalidCredentialsException extends Error {
-    code = 'INVALID_CREDENTIALS_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const invalidCredentialsException = (message) => new InvalidCredentialsException(message);
-
-class InvalidJobUrlException extends Error {
-    code = 'INVALID_JOB_URL_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-function invalidJobUrlException(message) {
-    return new InvalidJobUrlException(message);
-}
-
-class LoginFailedException extends Error {
-    code = 'LOGIN_FAILED_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const loginFailedException = (message) => {
-    return new LoginFailedException(message);
-};
-
-class MultiloginAuthenticationException extends Error {
-    code = 'MULTILOGIN_AUTHENTICATION_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const multiloginAuthenticationException = (message) => new MultiloginAuthenticationException(message);
-
-class NavigationTimeoutException extends Error {
-    code = 'NAVIGATION_TIMEOUT_EXCEPTION';
-    constructor(url, message) {
-        super(`Navigation to ${url} timed out: ${message}`);
-    }
-}
-const navigationTimeoutException = (url, message) => new NavigationTimeoutException(url, message);
-
-class NewBrowserPageException extends Error {
-    code = 'NEW_BROWSER_PAGE_EXCEPTION';
-    constructor(profileId, message) {
-        super(`Browser page for profile ${profileId} not found. \n\n Error Message: ${message}`);
-    }
-}
-const newBrowserPageException = (profileId, message) => new NewBrowserPageException(profileId, message);
-
-class NewPageException extends Error {
-    code = 'NEW_PAGE_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const newPageException = (message) => new NewPageException(message);
-
-class GoToUrlException extends Error {
-    code = 'GO_TO_URL_EXCEPTION';
-    constructor(url, message) {
-        super(`Error opening new url: ${url}. \n\n Error Message: ${message}`);
-    }
-}
-const goToUrlException = (url, message) => new GoToUrlException(url, message);
-
-class ParseConnectsException extends Error {
-    code = 'PARSE_CONNECTS_EXCEPTION';
-    constructor() {
-        super('Failed to parse connects');
-    }
-}
-const parseConnectsException = () => new ParseConnectsException();
-
-class ProposalErrorAlertException extends Error {
-    code = 'PROPOSAL_ERROR_ALERT_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const proposalErrorAlertException = (message) => new ProposalErrorAlertException(message);
-
-class ProposalFormWarningAlertException extends Error {
-    code = 'PROPOSAL_FORM_WARNING_ALERT_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-function proposalFormWarningAlertException(message) {
-    return new ProposalFormWarningAlertException(message);
-}
-
-class ProposalGenerationFailedException extends Error {
-    code = 'PROPOSAL_GENERATION_FAILED_EXCEPTION';
-    constructor(message, organizationId, campaignId, leadId) {
-        super(`Proposal generation failed for lead ${leadId} in campaign ${campaignId} in organization ${organizationId}\n\n${message}`);
-    }
-}
-const proposalGenerationFailed = (message, leadId, campaignId, organizationId) => new ProposalGenerationFailedException(message, organizationId, campaignId, leadId);
-
-class ProposalSubmitFailedException extends Error {
-    code = 'PROPOSAL_SUBMIT_FAILED';
-    constructor(message) {
-        super(message);
-    }
-}
-const proposalSubmitFailedException = (message) => {
-    return new ProposalSubmitFailedException(message);
-};
-
-class PuppeteerConnectionErrorException extends Error {
-    code = 'PUPPETEER_CONNECTION_ERROR_EXCEPTION';
-    constructor(message) {
-        super(message);
-    }
-}
-const puppeteerConnectionErrorException = (message) => new PuppeteerConnectionErrorException(message);
-
-class QuestionPairNotMatchingException extends Error {
-    code = 'QUESTION_PAIR_NOT_MATCHING';
-    constructor(upworkQuestion, generatedQuestion) {
-        super(`Question pair not matching: ${upworkQuestion} !== ${generatedQuestion}`);
-    }
-}
-const questionPairNotMatchingException = (upworkQuestion, generatedQuestion) => {
-    return new QuestionPairNotMatchingException(upworkQuestion, generatedQuestion);
-};
-
-class SelectAgencyException extends Error {
-    code = 'SELECT_AGENCY_EXCEPTION';
-    constructor(agencyName, message) {
-        super(`Failed to select agency ${agencyName}: ${message}`);
-    }
-}
-function selectAgencyException(agencyName, message) {
-    return new SelectAgencyException(agencyName, message);
-}
-
-class SelectContractorException extends Error {
-    code = 'SELECT_CONTRACTOR_EXCEPTION';
-    constructor(contractorName, message) {
-        super(`Failed to select contractor ${contractorName}: ${message}`);
-    }
-}
-function selectContractorException(contractorName, message) {
-    return new SelectContractorException(contractorName, message);
-}
-
-class SelectorNotFoundError extends Error {
-    code = 'SELECTOR_NOT_FOUND_ERROR';
-    constructor(selector, context) {
-        const message = context
-            ? `Element matching selector "${selector}" not found within ${context}.`
-            : `Element matching selector "${selector}" not found.`;
-        super(message);
-    }
-}
-const selectorNotFoundError = (selector, context) => new SelectorNotFoundError(selector, context);
-
-class TypedValueInFieldNotMatchingException extends Error {
-    code = 'TYPED_VALUE_IN_FIELD_NOT_MATCHING_EXCEPTION';
-    constructor(element, inputValue, correctValue) {
-        super(`Input value ${inputValue} does not match correct value ${correctValue} for element ${JSON.stringify(element)}`);
-    }
-}
-const typedValueInFieldNotMatchingException = (element, inputValue, correctValue) => new TypedValueInFieldNotMatchingException(element, inputValue, correctValue);
-
-class TypingInputFieldException extends Error {
-    code = 'TYPING_INPUT_FIELD_EXCEPTION';
-    constructor(element, message) {
-        const identifier = JSON.stringify(element);
-        super(`${identifier} - ${message}`);
-    }
-}
-const typingInputFieldException = (element, message) => new TypingInputFieldException(element, message);
-
-class WaitForFunctionTimeoutError extends Error {
-    code = 'WAIT_FOR_FUNCTION_TIMEOUT_ERROR';
-    constructor(fn, timeout) {
-        super(`Timeout waiting for function "${fn.toString()}" after ${timeout}ms.`);
-    }
-}
-const waitForFunctionTimeoutError = (fn, timeout) => new WaitForFunctionTimeoutError(fn, timeout);
-
-const usageEventTypeEnum = z.enum([
-    'suitabilityComplete',
-    'proposalComplete',
-    'biddingComplete',
-]);
-const usageEventMetadataSchema = objectType({
-    campaignId: stringType().nullable(),
-    userId: stringType().nullable(),
-    stripeSubscriptionId: stringType().nullable(),
-    planId: stringType().nullable(),
-});
-const usageEventSchema = objectType({
-    organizationId: stringType(),
-    typeId: usageEventTypeEnum,
-    timestamp: numberType(),
-    metadata: usageEventMetadataSchema,
-});
-
-const billingStripeMetadataSchema = objectType({
-    customer: objectType({ id: stringType().nullable() }),
-});
-const billingSchema = objectType({
-    savedCard: booleanType(),
-    stripe: billingStripeMetadataSchema,
-});
-
-const subscriptionStatusEnum = z.enum([
-    "active",
-    "trialing",
-    "cancelled",
-    "paused",
-    "payment_processing",
-    "payment_pending",
-    "payment_failed",
-]);
-const subscriptionSourceEnum = z.enum(["stripe", "manual"]);
-const subscriptionStripeMetadataItemSchema = objectType({
-    id: stringType(),
-    price: objectType({
-        id: stringType(),
-    }),
-});
-const subscriptionStripeMetadataSchema = objectType({
-    id: stringType(),
-    items: arrayType(subscriptionStripeMetadataItemSchema),
-    invoice: objectType({
-        id: stringType(),
-        hosted_invoice_url: stringType().nullable(),
-    }),
-});
-const subscriptionSchema = objectType({
-    planId: stringType(),
-    pendingPlanId: stringType().nullable(),
-    status: subscriptionStatusEnum,
-    startedAt: numberType(),
-    currentPeriodEnd: numberType(),
-    stripe: subscriptionStripeMetadataSchema,
-    source: subscriptionSourceEnum,
-    usage: recordType(usageEventTypeEnum, numberType()),
-});
-
-const coverLetterTemplateSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.string().nullable(),
-    template: z.string(),
-    instructions: z.string(),
-});
-const createCoverLetterTemplateSchema = coverLetterTemplateSchema.pick({
-    name: true,
-    template: true,
-    instructions: true,
-});
-
-const organizationMemberRoleEnum = z.enum(["admin", "member"]);
-const organizationMemberSchema = objectType({
-    role: organizationMemberRoleEnum,
-    joinedAt: numberType(),
-    invitedBy: stringType(),
-});
-
-const onboardingProgressSchema = z.object({
-    profileSetup: z.boolean(),
-    campaignCreated: z.boolean(),
-    filtersAdded: z.boolean(),
-    automationEnabled: z.boolean(),
-    startCampaign: z.boolean(),
-});
-
-const organizationTypeSchema = z.enum(['agency', 'freelancer']);
-const organizationTierEnum = z.enum(['free', 'premium']);
-const limitsSchema = objectType({
-    monthlyCredits: numberType(),
-    usedCredits: numberType(),
-    extraCredits: numberType(),
-});
-const oneTimePaymentSchema = z.object({
-    paidAt: z.number().optional(),
-    amount: z.number().optional(),
-    currency: z.string().optional(),
-    status: z.string(),
-    paymentIntentId: z.string().optional(),
-    error: z.string().optional(),
-});
-const oneTimePaymentsSchema = z.object({
-    usBidderAccountPayment: oneTimePaymentSchema.optional(),
-});
-const organizationSchema = objectType({
-    id: stringType(),
-    name: stringType(),
-    type: organizationTypeSchema,
-    associatedBidders: z.array(stringType()).nullable(),
-    subscription: subscriptionSchema.nullable(),
-    active: booleanType(),
-    limits: limitsSchema,
-    billing: billingSchema.nullable(),
-    lastBidTime: numberType().nullable(),
-    nextScheduledBidTime: numberType().nullable(),
-    createdAt: numberType(),
-    updatedAt: numberType(),
-    openRouterApiKey: stringType().nullable(),
-    appTrialEndsAt: numberType().nullable(),
-    oneTimePayments: oneTimePaymentsSchema.optional(),
-});
-const caseStudySchema = objectType({
-    id: stringType(),
-    title: stringType(),
-    description: stringType(),
-});
-z.object({
-    type: z.enum(['freelancer', 'agency']),
-    name: z.string(),
-    summary: z.string(),
-    coreServices: z.string(),
-    toolsSkillsTechnologies: z.string(),
-    approach: z.string(),
-    icp: z.string(),
-    projectsTheyAvoid: z.string(),
-    spokenLanguages: z.string(),
-    agencyInfo: z.object({
-        location: z.array(z.string()),
-        website: z.string().url(),
-        teamSize: z.number(),
-    }),
-    caseStudies: z.array(caseStudySchema),
-});
-const createOrganizationSchema = organizationSchema.pick({
-    name: true,
-    type: true,
-});
-const trackUsageEventTypeEnum = z.enum([
-    'suitabilityComplete',
-    'proposalComplete',
-    'biddingComplete',
-]);
-const trackUsagePayloadSchema = objectType({
-    event: usageEventTypeEnum,
-    campaignId: stringType().nullish(),
-});
-const questionRulesSchema = objectType({
-    question: stringType(),
-    answer: stringType(),
-    category: stringType(),
-});
-const aiConfigSchema = objectType({
-    questionHandling: z.string().nullable(),
-    questionRules: arrayType(questionRulesSchema).nullable(),
-    disqualifierRules: z.string().nullable(),
-    userInstructions: z.string().nullable(),
-});
-const notificationConfigSchema = objectType({
-    emailEnabled: booleanType(),
-    discordWebhookUrl: stringType().nullable(),
-    slackWebhookUrl: stringType().nullable(),
-});
-const organizationSettingsSchema = objectType({
-    aiConfig: aiConfigSchema,
-});
-const subscribePayloadSchema = objectType({
-    planId: stringType().min(1, 'Plan id is required.'),
-    paymentMethodId: stringType().min(1, 'Payment method is required.'),
-    toltReferral: stringType().optional(),
-    couponCode: stringType().nullish(),
-});
-
-const campaignExpensesSchema = z.object({
-    biddingAmount: z.number().default(0),
-    boostingAmount: z.number().default(0),
-    boosted: z.number().default(0),
-});
+const campaignExpensesSchema = z.object({
+    biddingAmount: z.number().default(0),
+    boostingAmount: z.number().default(0),
+    boosted: z.number().default(0),
+});
 
 const bidConfigSchema = z.object({
     agencyName: z.string().nullable(),
@@ -13263,6 +12951,11 @@ const campaignStatusSchema = z.union([
     z.literal('paused'),
     z.literal('error'),
 ]);
+const biddingHourlyRateStrategy = z.enum([
+    'match_job_budget',
+    'match_profile_rate',
+    'fixed_rate',
+]);
 const campaignSchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -13277,6 +12970,9 @@ const campaignSchema = z.object({
     monthlyBudget: z.number().nullable(),
     // suitabilityThreshold: z.number().min(0).max(100).nullable().default(0),
     boostingThreshold: z.number().min(0).max(100).nullable().default(0),
+    biddingDelayInMinutes: z.number().default(5),
+    biddingHourlyRateStrategy: biddingHourlyRateStrategy,
+    biddingFixedHourlyRate: z.number().nullable(),
     leadCounts: z.record(leadStatusSchema, z.number()).nullable(),
     expenses: campaignExpensesSchema,
     notificationsEnabled: z.boolean().nullable(),
@@ -13383,167 +13079,488 @@ const leadAnalysisActivityExtraSchema = z.object({
     suitabilityRating: z.number().min(0).max(100),
     creditBalance: z.number(),
 });
-const leadAnalysisActivitySchema = baseActivitySchema.extend({
-    ...leadAnalysisActivityExtraSchema.shape,
+const leadAnalysisActivitySchema = baseActivitySchema.extend({
+    ...leadAnalysisActivityExtraSchema.shape,
+});
+const leadStatusActivityExtraSchema = z.object({
+    type: z.literal("lead_status"),
+    status: leadStatusSchema,
+    lead: leadSchema.pick({
+        id: true,
+        title: true,
+        datetime: true,
+        jobUrl: true,
+    }),
+    creditBalance: z.number(),
+});
+const leadStatusActivitySchema = baseActivitySchema.extend({
+    ...leadStatusActivityExtraSchema.shape,
+});
+const proposalSentActivityExtraSchema = z.object({
+    type: z.literal("proposal_sent"),
+    lead: leadSchema.pick({
+        id: true,
+        title: true,
+        datetime: true,
+        jobUrl: true,
+    }),
+    creditBalance: z.number(),
+});
+const proposalSentActivitySchema = baseActivitySchema.extend({
+    ...proposalSentActivityExtraSchema.shape,
+});
+const campaignActivitySchema = z.discriminatedUnion("type", [
+    campaignStatusActivitySchema,
+    leadAnalysisActivitySchema,
+    leadStatusActivitySchema,
+    proposalSentActivitySchema,
+]);
+const campaignActivityCreateSchema = z.discriminatedUnion("type", [
+    campaignStatusActivityExtraSchema,
+    leadAnalysisActivityExtraSchema,
+    leadStatusActivityExtraSchema,
+    proposalSentActivityExtraSchema,
+]);
+const updateCampaignAnalyticsSchema = z.object({
+    organizationId: z.string(),
+    campaignId: z.string(),
+    fields: z.array(z.enum([
+        "contacted",
+        "viewed",
+        "replied",
+        "won",
+        "leadsAnalyzed",
+        "leadsFailed",
+        "proposalsFailed",
+        "suitableJobs",
+        "unsuitableJobs",
+        "wonAmount",
+    ])),
+});
+
+const campaignNotificationType = z.enum([
+    'suitableLead',
+    'proposalSent',
+    'proposalViewed',
+    'proposalReplied',
+    'noConnects',
+    'accountDisconnected',
+    'biddingWarning',
+]);
+const chatbotChannelSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+});
+const chatbotPlatforms = z.enum(['discord', 'slack']);
+const chatbotSchema = z.object({
+    accessToken: z.string().optional(),
+    refreshToken: z.string().optional(),
+    workspaceId: z.string(),
+    channels: z.array(chatbotChannelSchema),
+    selectedChannelId: z.string().nullable(),
+    notificationsEnabled: z.boolean().default(true),
+    notificationSettings: z.record(campaignNotificationType, z.boolean().default(true)),
+    organizationId: z.string(),
+    campaignId: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const createChatbotSchema = chatbotSchema.pick({
+    workspaceId: true,
+    accessToken: true,
+    refreshToken: true,
+    channels: true,
+    organizationId: true,
+    campaignId: true,
+});
+const updateChatbotSchema = chatbotSchema.pick({
+    selectedChannelId: true,
+    notificationsEnabled: true,
+    notificationSettings: true,
+});
+const sendNotificationRequestSchema = z.object({
+    organizationId: z.string(),
+    campaignId: z.string(),
+    leadId: z.string(),
+    notificationType: campaignNotificationType,
+    message: z.string().optional(),
+});
+const updateSuitableLeadNotificationType = z.enum([
+    'proceeded',
+    'feedback-provided',
+]);
+const updateSuitableLeadNotificationBodySchema = z.object({
+    type: updateSuitableLeadNotificationType,
+});
+const CAMPAIGN_NOTIFICATION_TYPES = {
+    suitableLead: 'Suitable Lead',
+    proposalSent: 'Proposal Sent',
+    proposalViewed: 'Proposal Viewed',
+    proposalReplied: 'Proposal Replied',
+    noConnects: 'No Connects',
+    accountDisconnected: 'Account Disconnected',
+    biddingWarning: 'Bidding Warning',
+};
+const CAMPAIGN_NOTIFICATION_SETTINGS = {
+    suitableLead: 'When Lancer determines a job is suitable for your company',
+    proposalSent: 'When a proposal is successfully submitted',
+    proposalViewed: 'When a client views your proposal',
+    proposalReplied: 'When a client replies to your proposal',
+    noConnects: 'When your Agency profile has run out of Upwork connects',
+    accountDisconnected: 'When there is an issue with your Upwork Bidder account',
+    biddingWarning: 'When there is a bidding warning',
+};
+
+const campaignCountByStatusSchema = z.object({
+    // Using z.enum values to create a schema with all possible job statuses
+    ...Object.fromEntries(Object.values(agentStatusSchema.enum).map((status) => [
+        status,
+        z.object({
+            boosted: z.number(),
+            organic: z.number(),
+            total: z.number(),
+        }),
+    ])),
+});
+const campaignInsightsSchema = z.object({
+    pipelineHealth: campaignCountByStatusSchema,
+    biddingAmount: z.number().default(0),
+    boostingAmount: z.number().default(0),
+    boostedProposalsCount: z.number().default(0),
+    totalProposalsCount: z.number().default(0),
+    totalExpenses: z.number().default(0),
+    suitabilityRange0to10: z.number(),
+    suitabilityRange10to20: z.number(),
+    suitabilityRange20to30: z.number(),
+    suitabilityRange30to40: z.number(),
+    suitabilityRange40to50: z.number(),
+    suitabilityRange50to60: z.number(),
+    suitabilityRange60to70: z.number(),
+    suitabilityRange70to80: z.number(),
+    suitabilityRange80to90: z.number(),
+    suitabilityRange90to100: z.number(),
+});
+
+const bidPayloadProposalDataSchema = z.object({
+    coverLetter: z.string(),
+    questionAnswerPairs: questionAnswerPairSchema.array().nullable(),
+    boostingEnabled: z.boolean(),
+    maximumBoost: z.number().nullable(),
+    biddingHourlyRateStrategy: biddingHourlyRateStrategy,
+    biddingFixedHourlyRate: z.number().nullable(),
+    isHourlyRate: z.boolean(),
+    jobMaxHourlyRate: z.number().nullable(),
 });
-const leadStatusActivityExtraSchema = z.object({
-    type: z.literal("lead_status"),
-    status: leadStatusSchema,
-    lead: leadSchema.pick({
-        id: true,
-        title: true,
-        datetime: true,
-        jobUrl: true,
-    }),
-    creditBalance: z.number(),
+const freelancerBidProposalDataSchema = bidPayloadProposalDataSchema;
+const agencyBidProposalDataSchema = bidPayloadProposalDataSchema.extend({
+    agencyName: z.string(),
+    contractorName: z.string(),
+    specializedProfile: z.string().nullable(),
 });
-const leadStatusActivitySchema = baseActivitySchema.extend({
-    ...leadStatusActivityExtraSchema.shape,
+const bidPayloadSchema = z.object({
+    organizationId: z.string(),
+    campaignId: z.string(),
+    lead: leadSchema,
+    jobUrl: z.string(),
+    username: z.string(),
+    password: z.string(),
 });
-const proposalSentActivityExtraSchema = z.object({
-    type: z.literal("proposal_sent"),
-    lead: leadSchema.pick({
-        id: true,
-        title: true,
-        datetime: true,
-        jobUrl: true,
-    }),
-    creditBalance: z.number(),
+const agencyBidPayloadSchema = bidPayloadSchema.extend({
+    proposalData: agencyBidProposalDataSchema,
 });
-const proposalSentActivitySchema = baseActivitySchema.extend({
-    ...proposalSentActivityExtraSchema.shape,
+const freelancerBidPayloadSchema = bidPayloadSchema.extend({
+    proposalData: freelancerBidProposalDataSchema,
 });
-const campaignActivitySchema = z.discriminatedUnion("type", [
-    campaignStatusActivitySchema,
-    leadAnalysisActivitySchema,
-    leadStatusActivitySchema,
-    proposalSentActivitySchema,
-]);
-const campaignActivityCreateSchema = z.discriminatedUnion("type", [
-    campaignStatusActivityExtraSchema,
-    leadAnalysisActivityExtraSchema,
-    leadStatusActivityExtraSchema,
-    proposalSentActivityExtraSchema,
-]);
-const updateCampaignAnalyticsSchema = z.object({
+const bidDtoSchema = z.object({
     organizationId: z.string(),
     campaignId: z.string(),
-    fields: z.array(z.enum([
-        "contacted",
-        "viewed",
-        "replied",
-        "won",
-        "leadsAnalyzed",
-        "leadsFailed",
-        "proposalsFailed",
-        "suitableJobs",
-        "unsuitableJobs",
-        "wonAmount",
-    ])),
+    leadId: z.string(),
+});
+
+const bidSuccessSchema = z.object({
+    status: z.literal("success"),
+    biddingAmount: z.number(),
+    boosted: z.boolean(),
+    boostingAmount: z.number(),
+});
+const bidFailedSchema = z.object({
+    status: z.literal("failed"),
+    errorMessage: z.string(),
 });
 
-const campaignNotificationType = z.enum([
-    'suitableLead',
-    'proposalSent',
-    'proposalViewed',
-    'proposalReplied',
-    'noConnects',
-    'accountDisconnected',
-    'biddingWarning',
-]);
-const chatbotChannelSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-});
-const chatbotPlatforms = z.enum(['discord', 'slack']);
-const chatbotSchema = z.object({
-    accessToken: z.string().optional(),
-    refreshToken: z.string().optional(),
-    workspaceId: z.string(),
-    channels: z.array(chatbotChannelSchema),
-    selectedChannelId: z.string().nullable(),
-    notificationsEnabled: z.boolean().default(true),
-    notificationSettings: z.record(campaignNotificationType, z.boolean().default(true)),
-    organizationId: z.string(),
-    campaignId: z.string(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-});
-const createChatbotSchema = chatbotSchema.pick({
-    workspaceId: true,
-    accessToken: true,
-    refreshToken: true,
-    channels: true,
-    organizationId: true,
-    campaignId: true,
-});
-const updateChatbotSchema = chatbotSchema.pick({
-    selectedChannelId: true,
-    notificationsEnabled: true,
-    notificationSettings: true,
-});
-const sendNotificationRequestSchema = z.object({
-    organizationId: z.string(),
-    campaignId: z.string(),
-    leadId: z.string(),
-    notificationType: campaignNotificationType,
-    message: z.string().optional(),
-});
-const updateSuitableLeadNotificationType = z.enum([
-    'proceeded',
-    'feedback-provided',
-]);
-const updateSuitableLeadNotificationBodySchema = z.object({
-    type: updateSuitableLeadNotificationType,
-});
-const CAMPAIGN_NOTIFICATION_TYPES = {
-    suitableLead: 'Suitable Lead',
-    proposalSent: 'Proposal Sent',
-    proposalViewed: 'Proposal Viewed',
-    proposalReplied: 'Proposal Replied',
-    noConnects: 'No Connects',
-    accountDisconnected: 'Account Disconnected',
-    biddingWarning: 'Bidding Warning',
+class CloudflareChallengeFailedException extends Error {
+    code = 'CLOUDFLARE_CHALLENGE_FAILED_EXCEPTION';
+    constructor(url, errorMessage) {
+        super(`Cloudflare challenge failed for ${url}\n\n ${errorMessage}`);
+    }
+}
+const cloudflareProtectionFailure = (url, errorMessage) => new CloudflareChallengeFailedException(url, errorMessage);
+
+class DeleteMultiloginProfileException extends Error {
+    code = 'DELETE_MULTILOGIN_PROFILE_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const deleteMultiloginProfileException = (message) => new DeleteMultiloginProfileException(message);
+
+class DropdownOptionNotPresentException extends Error {
+    code = 'DROPDOWN_OPTION_NOT_PRESENT_EXCEPTION';
+    constructor(selector, option) {
+        super(`${selector} does not contain option ${option}`);
+    }
+}
+function dropdownOptionNotPresentException(selector, option) {
+    return new DropdownOptionNotPresentException(selector, option);
+}
+
+class ElementNotClickableException extends Error {
+    code = 'ELEMENT_NOT_CLICKABLE_EXCEPTION';
+    constructor(context, message) {
+        super(`${context} is not clickable: ${message}`);
+    }
+}
+function elementNotClickableException(elementInfo, message) {
+    return new ElementNotClickableException(JSON.stringify(elementInfo), message);
+}
+
+class EvaluateElementException extends Error {
+    code = 'EVALUATE_ELEMENT_EXCEPTION';
+    constructor(element, message) {
+        super(`Element evaluation for ${JSON.stringify(element)} failed: ${message}`);
+    }
+}
+function evaluateElementException(element, message) {
+    return new EvaluateElementException(element, message);
+}
+
+class EvaluateFunctionException extends Error {
+    code = 'EVALUATE_FUNCTION_EXCEPTION';
+    constructor(fn, args, message) {
+        super(`Evaluation function ${fn.toString()} failed with selectors: ${args} \n\n Error Message: ${message}`);
+    }
+}
+function evaluateFunctionException(fn, args, message) {
+    return new EvaluateFunctionException(fn, args, message);
+}
+
+class GetMultiloginBrowserException extends Error {
+    code = 'GET_MULTILOGIN_BROWSER_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const getMultiloginBrowserException = (message) => new GetMultiloginBrowserException(message);
+
+class IncorrectSecurityQuestionAnswerException extends Error {
+    code = 'INCORRECT_SECURITY_QUESTION_ANSWER_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const incorrectSecurityQuestionAnswerException = (message) => new IncorrectSecurityQuestionAnswerException(message);
+
+class InitBrowserException extends Error {
+    code = 'INIT_BROWSER_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const initBrowserException = (message) => new InitBrowserException(message);
+
+class InsufficientConnectsException extends Error {
+    code = 'INSUFFICIENT_CONNECTS_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const insufficientConnectsException = (message) => new InsufficientConnectsException(message);
+
+class InvalidCredentialsException extends Error {
+    code = 'INVALID_CREDENTIALS_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const invalidCredentialsException = (message) => new InvalidCredentialsException(message);
+
+class InvalidJobUrlException extends Error {
+    code = 'INVALID_JOB_URL_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+function invalidJobUrlException(message) {
+    return new InvalidJobUrlException(message);
+}
+
+class LoginFailedException extends Error {
+    code = 'LOGIN_FAILED_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const loginFailedException = (message) => {
+    return new LoginFailedException(message);
+};
+
+class MultiloginAuthenticationException extends Error {
+    code = 'MULTILOGIN_AUTHENTICATION_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const multiloginAuthenticationException = (message) => new MultiloginAuthenticationException(message);
+
+class NavigationTimeoutException extends Error {
+    code = 'NAVIGATION_TIMEOUT_EXCEPTION';
+    constructor(url, message) {
+        super(`Navigation to ${url} timed out: ${message}`);
+    }
+}
+const navigationTimeoutException = (url, message) => new NavigationTimeoutException(url, message);
+
+class NewBrowserPageException extends Error {
+    code = 'NEW_BROWSER_PAGE_EXCEPTION';
+    constructor(profileId, message) {
+        super(`Browser page for profile ${profileId} not found. \n\n Error Message: ${message}`);
+    }
+}
+const newBrowserPageException = (profileId, message) => new NewBrowserPageException(profileId, message);
+
+class NewPageException extends Error {
+    code = 'NEW_PAGE_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const newPageException = (message) => new NewPageException(message);
+
+class GoToUrlException extends Error {
+    code = 'GO_TO_URL_EXCEPTION';
+    constructor(url, message) {
+        super(`Error opening new url: ${url}. \n\n Error Message: ${message}`);
+    }
+}
+const goToUrlException = (url, message) => new GoToUrlException(url, message);
+
+class ParseConnectsException extends Error {
+    code = 'PARSE_CONNECTS_EXCEPTION';
+    constructor() {
+        super('Failed to parse connects');
+    }
+}
+const parseConnectsException = () => new ParseConnectsException();
+
+class ProposalErrorAlertException extends Error {
+    code = 'PROPOSAL_ERROR_ALERT_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const proposalErrorAlertException = (message) => new ProposalErrorAlertException(message);
+
+class ProposalFormWarningAlertException extends Error {
+    code = 'PROPOSAL_FORM_WARNING_ALERT_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+function proposalFormWarningAlertException(message) {
+    return new ProposalFormWarningAlertException(message);
+}
+
+class ProposalGenerationFailedException extends Error {
+    code = 'PROPOSAL_GENERATION_FAILED_EXCEPTION';
+    constructor(message, organizationId, campaignId, leadId) {
+        super(`Proposal generation failed for lead ${leadId} in campaign ${campaignId} in organization ${organizationId}\n\n${message}`);
+    }
+}
+const proposalGenerationFailed = (message, leadId, campaignId, organizationId) => new ProposalGenerationFailedException(message, organizationId, campaignId, leadId);
+
+class ProposalSubmitFailedException extends Error {
+    code = 'PROPOSAL_SUBMIT_FAILED';
+    constructor(message) {
+        super(message);
+    }
+}
+const proposalSubmitFailedException = (message) => {
+    return new ProposalSubmitFailedException(message);
 };
-const CAMPAIGN_NOTIFICATION_SETTINGS = {
-    suitableLead: 'When Lancer determines a job is suitable for your company',
-    proposalSent: 'When a proposal is successfully submitted',
-    proposalViewed: 'When a client views your proposal',
-    proposalReplied: 'When a client replies to your proposal',
-    noConnects: 'When your Agency profile has run out of Upwork connects',
-    accountDisconnected: 'When there is an issue with your Upwork Bidder account',
-    biddingWarning: 'When there is a bidding warning',
+
+class PuppeteerConnectionErrorException extends Error {
+    code = 'PUPPETEER_CONNECTION_ERROR_EXCEPTION';
+    constructor(message) {
+        super(message);
+    }
+}
+const puppeteerConnectionErrorException = (message) => new PuppeteerConnectionErrorException(message);
+
+class QuestionPairNotMatchingException extends Error {
+    code = 'QUESTION_PAIR_NOT_MATCHING';
+    constructor(upworkQuestion, generatedQuestion) {
+        super(`Question pair not matching: ${upworkQuestion} !== ${generatedQuestion}`);
+    }
+}
+const questionPairNotMatchingException = (upworkQuestion, generatedQuestion) => {
+    return new QuestionPairNotMatchingException(upworkQuestion, generatedQuestion);
 };
 
-const campaignCountByStatusSchema = z.object({
-    // Using z.enum values to create a schema with all possible job statuses
-    ...Object.fromEntries(Object.values(agentStatusSchema.enum).map((status) => [
-        status,
-        z.object({
-            boosted: z.number(),
-            organic: z.number(),
-            total: z.number(),
-        }),
-    ])),
-});
-const campaignInsightsSchema = z.object({
-    pipelineHealth: campaignCountByStatusSchema,
-    biddingAmount: z.number().default(0),
-    boostingAmount: z.number().default(0),
-    boostedProposalsCount: z.number().default(0),
-    totalProposalsCount: z.number().default(0),
-    totalExpenses: z.number().default(0),
-    suitabilityRange0to10: z.number(),
-    suitabilityRange10to20: z.number(),
-    suitabilityRange20to30: z.number(),
-    suitabilityRange30to40: z.number(),
-    suitabilityRange40to50: z.number(),
-    suitabilityRange50to60: z.number(),
-    suitabilityRange60to70: z.number(),
-    suitabilityRange70to80: z.number(),
-    suitabilityRange80to90: z.number(),
-    suitabilityRange90to100: z.number(),
-});
+class SelectAgencyException extends Error {
+    code = 'SELECT_AGENCY_EXCEPTION';
+    constructor(agencyName, message) {
+        super(`Failed to select agency ${agencyName}: ${message}`);
+    }
+}
+function selectAgencyException(agencyName, message) {
+    return new SelectAgencyException(agencyName, message);
+}
+
+class SelectContractorException extends Error {
+    code = 'SELECT_CONTRACTOR_EXCEPTION';
+    constructor(contractorName, message) {
+        super(`Failed to select contractor ${contractorName}: ${message}`);
+    }
+}
+function selectContractorException(contractorName, message) {
+    return new SelectContractorException(contractorName, message);
+}
+
+class SelectorNotFoundError extends Error {
+    code = 'SELECTOR_NOT_FOUND_ERROR';
+    constructor(selector, context) {
+        const message = context
+            ? `Element matching selector "${selector}" not found within ${context}.`
+            : `Element matching selector "${selector}" not found.`;
+        super(message);
+    }
+}
+const selectorNotFoundError = (selector, context) => new SelectorNotFoundError(selector, context);
+
+class TypedValueInFieldNotMatchingException extends Error {
+    code = 'TYPED_VALUE_IN_FIELD_NOT_MATCHING_EXCEPTION';
+    constructor(element, inputValue, correctValue) {
+        super(`Input value ${inputValue} does not match correct value ${correctValue} for element ${JSON.stringify(element)}`);
+    }
+}
+const typedValueInFieldNotMatchingException = (element, inputValue, correctValue) => new TypedValueInFieldNotMatchingException(element, inputValue, correctValue);
+
+class TypingInputFieldException extends Error {
+    code = 'TYPING_INPUT_FIELD_EXCEPTION';
+    constructor(element, message) {
+        const identifier = JSON.stringify(element);
+        super(`${identifier} - ${message}`);
+    }
+}
+const typingInputFieldException = (element, message) => new TypingInputFieldException(element, message);
+
+class WaitForFunctionTimeoutError extends Error {
+    code = 'WAIT_FOR_FUNCTION_TIMEOUT_ERROR';
+    constructor(fn, timeout) {
+        super(`Timeout waiting for function "${fn.toString()}" after ${timeout}ms.`);
+    }
+}
+const waitForFunctionTimeoutError = (fn, timeout) => new WaitForFunctionTimeoutError(fn, timeout);
 
 const invoiceStripeMetadataLineSchema = objectType({
     description: stringType(),
@@ -13986,8 +14003,8 @@ const upworkProfileSchema = objectType({
 });
 
 class NoScraperAccountAvailableException extends Error {
-    code = 'NO_SCRAPER_ACCOUNT_AVAILABLE';
-    constructor(message = 'No scraper account available.') {
+    code = "NO_SCRAPER_ACCOUNT_AVAILABLE";
+    constructor(message = "No scraper account available.") {
         super(message);
     }
 }
@@ -13995,8 +14012,8 @@ const noScraperAccountAvailableException = (message) => {
     return new NoScraperAccountAvailableException(message);
 };
 class OpenPageException extends Error {
-    code = 'OPEN_PAGE_FAILED';
-    constructor(message = 'Failed to open page.') {
+    code = "OPEN_PAGE_FAILED";
+    constructor(message = "Failed to open page.") {
         super(message);
     }
 }
@@ -14004,8 +14021,8 @@ const openPageException = (message) => {
     return new OpenPageException(message);
 };
 class FeedScrapeException extends Error {
-    code = 'FEED_SCRAPE_FAILED';
-    constructor(message = 'Feed scrape failed.') {
+    code = "FEED_SCRAPE_FAILED";
+    constructor(message = "Feed scrape failed.") {
         super(message);
     }
 }
@@ -14013,8 +14030,8 @@ const feedScrapeException = (message) => {
     return new FeedScrapeException(message);
 };
 class ParseJobListingsException extends Error {
-    code = 'PARSE_JOB_LISTINGS_FAILED';
-    constructor(message = 'Failed to parse job listings.') {
+    code = "PARSE_JOB_LISTINGS_FAILED";
+    constructor(message = "Failed to parse job listings.") {
         super(message);
     }
 }
@@ -14022,7 +14039,7 @@ const parseJobListingsException = (message) => {
     return new ParseJobListingsException(message);
 };
 class ScrapeJobDetailsException extends Error {
-    code = 'SCRAPE_JOB_DETAILS_FAILED';
+    code = "SCRAPE_JOB_DETAILS_FAILED";
     constructor(jobListing) {
         super(`Failed to scrape job details for ${JSON.stringify(jobListing)}.`);
     }
@@ -14030,6 +14047,28 @@ class ScrapeJobDetailsException extends Error {
 const scrapeJobDetailsException = (jobListing) => {
     return new ScrapeJobDetailsException(jobListing);
 };
+class ParseUpworkProfilesException extends Error {
+    code = "PARSE_JOB_PROFILES_FAILED";
+    constructor(message = "Failed to parse profiles.") {
+        super(message);
+    }
+}
+const parseUpworkProfilesException = (message) => {
+    return new ParseUpworkProfilesException(message);
+};
+class ScraperAccountProxyNotFoundException extends Error {
+    scraperAccountId;
+    proxyId;
+    code = "SCRAPER_ACCOUNT_PROXY_NOT_FOUND";
+    constructor(scraperAccountId, proxyId, message = "Scraper account proxy not found.") {
+        super(message);
+        this.scraperAccountId = scraperAccountId;
+        this.proxyId = proxyId;
+    }
+}
+const scraperAccountProxyNotFoundException = (scraperAccountId, proxyId, message) => {
+    return new ScraperAccountProxyNotFoundException(scraperAccountId, proxyId, message);
+};
 
 const systemPromptSchema = objectType({
     suitability: stringType(),
@@ -14194,6 +14233,125 @@ const bidderInstanceSchema = objectType({
     updatedAt: numberType(),
 });
 
+const skillSchema = objectType({
+    skill: objectType({
+        prettyName: stringType(),
+        uid: stringType(),
+    }),
+    uid: stringType(),
+});
+const portfolioItemSchema = objectType({
+    description: stringType().nullable(),
+    title: stringType(),
+    videoUrl: stringType().nullable(),
+    uid: stringType(),
+    thumbnailUrl: stringType().nullable(),
+    publicPortfolioItem: booleanType(),
+    category: objectType({
+        id: stringType().nullable(),
+        level1: stringType().nullable(),
+        level2: stringType().nullable(),
+    }),
+});
+const profileSchema = objectType({
+    title: stringType(),
+    firstName: stringType(),
+    lastName: stringType(),
+    description: stringType(),
+    location: objectType({
+        country: stringType(),
+        state: stringType().nullable(),
+        city: stringType().nullable(),
+        region: stringType(),
+        subregion: stringType(),
+        timezone: stringType(),
+        zip: stringType().nullable(),
+    }),
+    chargeRate: objectType({
+        rawValue: stringType(),
+        currency: stringType(),
+    }),
+    portrait: objectType({
+        portrait: stringType(),
+    }),
+    profileUrl: stringType(),
+    offerConsultations: booleanType(),
+    jobSummariesAssignmentRids: anyType().nullable(),
+    shortName: stringType(),
+    skills: arrayType(skillSchema),
+    stats: objectType({
+        hideJss: booleanType(),
+        hideEarnings: booleanType(),
+        topRatedStatus: stringType(),
+        topRatedStatusEx: stringType(),
+        rate: numberType(),
+        earned: numberType(),
+        jobSuccessScore: numberType(),
+        rankInfo: anyType().nullable(),
+        totalHours: numberType(),
+        totalHourlyJobs: numberType(),
+        totalFpJobs: numberType(),
+        totalCompletedJobs: numberType(),
+    }),
+    portfolioItems: arrayType(portfolioItemSchema),
+    totalPortfolioItems: numberType(),
+    specializedProfiles: arrayType(anyType()),
+    isDiversityCertified: booleanType(),
+    isBoosted: booleanType(),
+    boosted: booleanType(),
+    boostedWouldHaveBeen: booleanType(),
+});
+const nuxtStateProfileSchema = objectType({
+    identity: objectType({
+        id: stringType(),
+        ciphertext: stringType(),
+        uid: stringType(),
+    }),
+    isPIBAvailable: booleanType(),
+    profile: profileSchema,
+    agency: objectType({
+        orgId: stringType(),
+        ciphertext: stringType(),
+        name: stringType(),
+        classifications: arrayType(anyType()),
+        logo: stringType().nullable(),
+        hideEarnings: booleanType(),
+        totalEarnings: numberType(),
+        isAgencyDiversityCertified: arrayType(anyType()),
+    }),
+    options: objectType({
+        position: numberType(),
+    }),
+});
+const nuxtStateProfilesSearchSchema = objectType({
+    status: objectType({
+        loading: booleanType(),
+        loaded: booleanType(),
+        failed: booleanType(),
+    }),
+    profiles: arrayType(nuxtStateProfileSchema),
+    currentPage: numberType(),
+    paging: objectType({
+        total: numberType(),
+        offset: numberType(),
+        count: numberType(),
+        originTotal: numberType(),
+        pagesTotal: numberType(),
+        page: numberType(),
+        perPage: numberType(),
+    }),
+    flags: objectType({
+        portfolioSearch: booleanType(),
+    }),
+    searchQueryCache: recordType(stringType()),
+    "handle-response-data": recordType(anyType()),
+});
+const profileSearchNuxtStateSchema = objectType({
+    state: objectType({
+        profilesSearch: nuxtStateProfilesSearchSchema,
+    }),
+});
+
 // Main wrapper function
 async function tryCatch(promise) {
     try {
@@ -14600,6 +14758,7 @@ exports.NoScraperAccountAvailableException = NoScraperAccountAvailableException;
 exports.OpenPageException = OpenPageException;
 exports.ParseConnectsException = ParseConnectsException;
 exports.ParseJobListingsException = ParseJobListingsException;
+exports.ParseUpworkProfilesException = ParseUpworkProfilesException;
 exports.ProposalErrorAlertException = ProposalErrorAlertException;
 exports.ProposalFormWarningAlertException = ProposalFormWarningAlertException;
 exports.ProposalGenerationFailedException = ProposalGenerationFailedException;
@@ -14608,6 +14767,7 @@ exports.PuppeteerConnectionErrorException = PuppeteerConnectionErrorException;
 exports.QuestionPairNotMatchingException = QuestionPairNotMatchingException;
 exports.ROUTES = ROUTES;
 exports.ScrapeJobDetailsException = ScrapeJobDetailsException;
+exports.ScraperAccountProxyNotFoundException = ScraperAccountProxyNotFoundException;
 exports.SelectAgencyException = SelectAgencyException;
 exports.SelectContractorException = SelectContractorException;
 exports.SelectorNotFoundError = SelectorNotFoundError;
@@ -14643,6 +14803,7 @@ exports.bidderInstanceSchema = bidderInstanceSchema;
 exports.bidderInstanceStatusEnum = bidderInstanceStatusEnum;
 exports.biddingCompletedEventMetadata = biddingCompletedEventMetadata;
 exports.biddingFailedEventMetadata = biddingFailedEventMetadata;
+exports.biddingHourlyRateStrategy = biddingHourlyRateStrategy;
 exports.biddingRejectedWithFeedbackEventMetadata = biddingRejectedWithFeedbackEventMetadata;
 exports.booleanSchema = booleanSchema;
 exports.buildRoute = buildRoute;
@@ -14770,6 +14931,7 @@ exports.notificationConfigSchema = notificationConfigSchema;
 exports.nuxtStateJobDetailsSchema = nuxtStateJobDetailsSchema;
 exports.nuxtStateJobSchema = nuxtStateJobSchema;
 exports.nuxtStateJobsSearchSchema = nuxtStateJobsSearchSchema;
+exports.nuxtStateProfilesSearchSchema = nuxtStateProfilesSearchSchema;
 exports.onboardingProgressSchema = onboardingProgressSchema;
 exports.openPageException = openPageException;
 exports.organizationCampaignStatsSchema = organizationCampaignStatsSchema;
@@ -14779,18 +14941,22 @@ exports.organizationSchema = organizationSchema;
 exports.organizationSettingsSchema = organizationSettingsSchema;
 exports.organizationTierEnum = organizationTierEnum;
 exports.organizationTypeSchema = organizationTypeSchema;
+exports.organizationUpdateSchema = organizationUpdateSchema;
 exports.parseConnectsException = parseConnectsException;
 exports.parseJobListingsException = parseJobListingsException;
+exports.parseUpworkProfilesException = parseUpworkProfilesException;
 exports.passwordSchema = passwordSchema;
 exports.paymentTypeEnum = paymentTypeEnum;
 exports.periodTypeSchema = periodTypeSchema;
 exports.periodUsageSchema = periodUsageSchema;
 exports.planFeatureSchema = planFeatureSchema;
 exports.planSchema = planSchema;
+exports.planSlugToNameMap = planSlugToNameMap;
 exports.planStripeMetadataSchema = planStripeMetadataSchema;
 exports.pluralize = pluralize;
 exports.portfolioSchema = portfolioSchema;
 exports.processFeedPayloadSchema = processFeedPayloadSchema;
+exports.profileSearchNuxtStateSchema = profileSearchNuxtStateSchema;
 exports.projectDurationEnum = projectDurationEnum;
 exports.proposalCompleteEventMetadataSchema = proposalCompleteEventMetadataSchema;
 exports.proposalErrorAlertException = proposalErrorAlertException;
@@ -14835,6 +15001,7 @@ exports.scrapePayloadSchema = scrapePayloadSchema;
 exports.scrapeResultSchema = scrapeResultSchema;
 exports.scrapeUserProfileRequestSchema = scrapeUserProfileRequestSchema;
 exports.scraperAccountErrorEventMetadata = scraperAccountErrorEventMetadata;
+exports.scraperAccountProxyNotFoundException = scraperAccountProxyNotFoundException;
 exports.scraperAccountRegionEnum = scraperAccountRegionEnum;
 exports.scraperAccountSchema = scraperAccountSchema;
 exports.scraperAccountType = scraperAccountType;