lancer-shared 1.2.91 → 1.2.92

package/dist/schemas/lead/nuxt.js

@@ -1,287 +0,0 @@
-import { any, array, boolean, number, object, record, string } from "zod";
-const segmentationDataSchema = object({
-    customValue: string().nullable(),
-    label: string(),
-    name: string(),
-    sortOrder: number(),
-    type: string(),
-    value: string(),
-    skill: any().nullable(),
-});
-const clientActivitySchema = object({
-    lastBuyerActivity: string(),
-    totalApplicants: number(),
-    totalHired: number(),
-    totalInvitedToInterview: number(),
-    unansweredInvites: number(),
-    invitationsSent: number(),
-    numberOfPositionsToHire: number(),
-});
-const annotationsSchema = object({
-    tags: array(string()),
-});
-const budgetSchema = object({
-    amount: number(),
-    currencyCode: string(),
-});
-const engagementDurationSchema = object({
-    label: string(),
-    weeks: number(),
-});
-const extendedBudgetInfoSchema = object({
-    hourlyBudgetMin: number().nullable(),
-    hourlyBudgetMax: number().nullable(),
-    hourlyBudgetType: string().nullable(),
-});
-const qualificationsSchema = object({
-    countries: any().nullable(),
-    earnings: any().nullable(),
-    groupRecno: any().nullable(),
-    languages: any().nullable(),
-    localDescription: any().nullable(),
-    localFlexibilityDescription: any().nullable(),
-    localMarket: boolean(),
-    minJobSuccessScore: number(),
-    minOdeskHours: number(),
-    onSiteType: any().nullable(),
-    prefEnglishSkill: number(),
-    regions: any().nullable(),
-    risingTalent: boolean(),
-    shouldHavePortfolio: boolean(),
-    states: any().nullable(),
-    tests: any().nullable(),
-    timezones: any().nullable(),
-    type: number(),
-    locationCheckRequired: boolean(),
-    group: any().nullable(),
-    location: any().nullable(),
-    locations: any().nullable(),
-});
-const jobSchema = object({
-    status: number(),
-    category: object({
-        name: string(),
-        urlSlug: string(),
-    }),
-    categoryGroup: object({
-        name: string(),
-        urlSlug: string(),
-    }),
-    budget: budgetSchema,
-    postedOn: string(),
-    publishTime: string(),
-    wasRenewed: boolean(),
-    startDate: string().nullable(),
-    deliveryDate: string().nullable(),
-    workload: string().nullable(),
-    engagementDuration: engagementDurationSchema,
-    extendedBudgetInfo: extendedBudgetInfoSchema,
-    contractorTier: number(),
-    description: string(),
-    segmentationData: array(segmentationDataSchema),
-    clientActivity: clientActivitySchema,
-    annotations: annotationsSchema,
-    uid: string(),
-    title: string(),
-    type: number(),
-    ciphertext: string(),
-    access: number(),
-    createdOn: string(),
-    hideBudget: boolean(),
-    notSureProjectDuration: boolean(),
-    notSureFreelancersToHire: boolean(),
-    notSureExperienceLevel: boolean(),
-    numberOfPositionsToHire: number(),
-    isContractToHire: boolean(),
-    attachments: array(any()),
-    isPremium: boolean(),
-    qualifications: qualificationsSchema,
-    questions: array(object({ question: string(), position: number() })),
-    durationIdV3: number(),
-    durationLabel: string(),
-});
-const buyerSchema = object({
-    isEnterprise: boolean(),
-    isPaymentMethodVerified: boolean(),
-    stats: object({
-        totalAssignments: number(),
-        activeAssignmentsCount: number(),
-        hoursCount: number(),
-        feedbackCount: number(),
-        score: number(),
-        totalJobsWithHires: number(),
-        totalCharges: object({
-            amount: number(),
-        }),
-    }),
-    location: object({
-        offsetFromUtcMillis: number(),
-        countryTimezone: string(),
-        city: string(),
-        country: string(),
-    }),
-    company: object({
-        isEDCReplicated: any().nullable(),
-        contractDate: string(),
-        profile: object({
-            industry: string(),
-            size: number(),
-        }),
-        name: string().nullable(),
-    }),
-    jobs: object({
-        postedCount: number(),
-        openCount: number(),
-    }),
-    avgHourlyJobsRate: object({
-        amount: number(),
-    }).nullable(),
-});
-const currentUserInfoSchema = object({
-    owner: boolean(),
-    freelancerInfo: object({
-        profileState: string(),
-        applied: any().nullable(),
-        devProfileCiphertext: string(),
-        hired: any().nullable(),
-        application: record(any()),
-        pendingInvite: record(any()),
-        contract: any().nullable(),
-        hourlyRate: object({
-            amount: number(),
-        }),
-        qualificationsMatches: object({
-            matches: array(object({
-                clientPreferred: string(),
-                clientPreferredLabel: string().nullable(),
-                freelancerValue: string(),
-                freelancerValueLabel: string(),
-                qualification: number(),
-                qualified: boolean(),
-            })),
-        }),
-    }),
-});
-const workHistorySchema = array(object({
-    isPtcJob: any().nullable(),
-    status: any().nullable(),
-    isEDCReplicated: any().nullable(),
-    startDate: string(),
-    endDate: string(),
-    totalCharge: number(),
-    totalHours: number(),
-    jobInfo: object({
-        title: string(),
-        id: any().nullable(),
-        uid: any().nullable(),
-        access: number(),
-        type: number(),
-        ciphertext: any().nullable(),
-    }),
-    contractorInfo: object({
-        contractorName: string(),
-        accessType: string(),
-        ciphertext: string(),
-    }),
-    rate: object({
-        amount: number(),
-    }).nullable(),
-    feedback: object({
-        feedbackSuppressed: boolean(),
-        score: number(),
-        comment: string(),
-        feedback_suppressed: boolean(),
-    }),
-    feedbackToClient: object({
-        feedbackSuppressed: boolean(),
-        score: number(),
-        comment: string(),
-        feedback_suppressed: boolean(),
-    }),
-    isEDCPublic: boolean(),
-}));
-const sandsSchema = object({
-    occupation: object({
-        freeText: string().nullable(),
-        ontologyId: string(),
-        prefLabel: string(),
-        id: string(),
-        uid: string(),
-    }),
-    ontologySkills: array(any()),
-    additionalSkills: array(object({
-        uid: string(),
-        name: string(),
-        isFreeText: boolean(),
-    })),
-});
-const connectsSchema = object({
-    pricing: object({
-        price: number(),
-        context: string(),
-        auctionPrice: number(),
-    }),
-    requiredConnects: number(),
-    availableConnects: number(),
-    chooseConnectsStatus: object({
-        isExplainerModalShown: boolean().nullable(),
-    }),
-    canSeeApplicantsRates: boolean(),
-});
-const authSchema = object({
-    canFlagOpening: boolean(),
-    canPostJob: boolean(),
-    domestic: object({
-        country: string().nullable(),
-        isInfographicTooltipAvailable: boolean(),
-    }),
-});
-const applicationContextSchema = object({
-    freelancerAllowed: boolean(),
-    clientAllowed: boolean(),
-    userIntentEvaluation: object({
-        isDeclined: boolean(),
-        reason: string().nullable(),
-    }),
-    canApplyOnBehalfOfAgencyFreelancers: boolean(),
-    canSubmitMoreProposals: boolean(),
-    submittedProposals: any().nullable(),
-});
-export const nuxtStateJobSchema = object({
-    cache: boolean(),
-    job: jobSchema,
-    buyer: buyerSchema,
-    currentUserInfo: currentUserInfoSchema,
-    isVisitor: boolean(),
-    openJobs: array(any()),
-    workHistory: workHistorySchema,
-    similarJobs: array(any()),
-    sands: sandsSchema,
-    auth: authSchema,
-    applicants: object({
-        applicantsBidsStats: any().nullable(),
-    }),
-    connects: connectsSchema.nullish(),
-    enterpriseJobAdditionalInfo: record(any()),
-    applicationContext: applicationContextSchema,
-    profileMatchServiceUid: string(),
-    seo: object({
-        title: string(),
-        description: string(),
-        url: string(),
-    }),
-    teamUid: any().nullable(),
-    proposalPermissions: object({
-        freelancerAllowed: boolean(),
-        clientAllowed: boolean(),
-    }),
-    jobSlug: any().nullable(),
-    prefillWith: any().nullable(),
-    isGroupOpportunity: boolean(),
-    workLocation: any().nullable(),
-    isPhoneVerified: boolean(),
-    errorResponse: any().nullable(),
-    isApplyBlocked: boolean(),
-    hasAiInterview: boolean(),
-    talentFeePromotion: boolean().nullish(),
-});

package/dist/schemas/meter-event/index.d.ts

@@ -1,12 +0,0 @@
-export declare const usageEventSchema: import("zod").ZodObject<{
-    organizationId: import("zod").ZodString;
-    eventId: any;
-}, "strip", import("zod").ZodTypeAny, {
-    [x: string]: any;
-    organizationId?: unknown;
-    eventId?: unknown;
-}, {
-    [x: string]: any;
-    organizationId?: unknown;
-    eventId?: unknown;
-}>;

package/dist/schemas/organization/member.js

@@ -1,7 +0,0 @@
-import { number, object, string, z } from "zod";
-export const organizationMemberRoleEnum = z.enum(["admin", "member"]);
-export const organizationMemberSchema = object({
-    role: organizationMemberRoleEnum,
-    joinedAt: number(),
-    invitedBy: string(),
-});

package/dist/schemas/organization/subscription.js

@@ -1,17 +0,0 @@
-import { number, object, string, z } from "zod";
-export const subscriptionStatusEnum = z.enum([
-    "active",
-    "trialing",
-    "cancelled",
-    "paused",
-]);
-export const subscriptionSourceEnum = z.enum(["stripe", "manual"]);
-export const organizationSubscriptionSchema = object({
-    tierId: string(),
-    status: subscriptionStatusEnum,
-    creditsRemaining: number(),
-    startedAt: number(),
-    currentPeriodEnd: number(),
-    stripeSubscriptionId: string(),
-    source: subscriptionSourceEnum,
-});

package/dist/schemas/proxy/proxy-available-replacements.js

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-import { proxyProviderSchema } from './proxy';
-export const proxyAvailableReplacementsSchema = z.record(proxyProviderSchema, z.number());

package/dist/schemas/proxy/proxy-country.js

@@ -1,249 +0,0 @@
-import { z } from 'zod';
-export const proxyCountrySchema = z.enum([
-    'US',
-    'CA',
-    'GB',
-    'AF',
-    'AX',
-    'AL',
-    'DZ',
-    'AS',
-    'AD',
-    'AO',
-    'AI',
-    'AQ',
-    'AG',
-    'AR',
-    'AM',
-    'AW',
-    'AU',
-    'AT',
-    'AZ',
-    'BS',
-    'BH',
-    'BD',
-    'BB',
-    'BY',
-    'BE',
-    'BZ',
-    'BJ',
-    'BM',
-    'BT',
-    'BO',
-    'BA',
-    'BW',
-    'BV',
-    'BR',
-    'IO',
-    'BN',
-    'BG',
-    'BF',
-    'BI',
-    'KH',
-    'CM',
-    'CV',
-    'KY',
-    'CF',
-    'TD',
-    'CL',
-    'CN',
-    'CX',
-    'CC',
-    'CO',
-    'KM',
-    'CG',
-    'CD',
-    'CK',
-    'CR',
-    'CI',
-    'HR',
-    'CU',
-    'CY',
-    'CZ',
-    'DK',
-    'DJ',
-    'DM',
-    'DO',
-    'EC',
-    'EG',
-    'SV',
-    'GQ',
-    'ER',
-    'EE',
-    'ET',
-    'FK',
-    'FO',
-    'FJ',
-    'FI',
-    'FR',
-    'GF',
-    'PF',
-    'TF',
-    'GA',
-    'GM',
-    'GE',
-    'DE',
-    'GH',
-    'GI',
-    'GR',
-    'GL',
-    'GD',
-    'GP',
-    'GU',
-    'GT',
-    'GG',
-    'GN',
-    'GW',
-    'GY',
-    'HT',
-    'HM',
-    'VA',
-    'HN',
-    'HK',
-    'HU',
-    'IS',
-    'IN',
-    'ID',
-    'IR',
-    'IQ',
-    'IE',
-    'IM',
-    'IL',
-    'IT',
-    'JM',
-    'JP',
-    'JE',
-    'JO',
-    'KZ',
-    'KE',
-    'KI',
-    'KP',
-    'KR',
-    'KW',
-    'KG',
-    'LA',
-    'LV',
-    'LB',
-    'LS',
-    'LR',
-    'LY',
-    'LI',
-    'LT',
-    'LU',
-    'MO',
-    'MK',
-    'MG',
-    'MW',
-    'MY',
-    'MV',
-    'ML',
-    'MT',
-    'MH',
-    'MQ',
-    'MR',
-    'MU',
-    'YT',
-    'MX',
-    'FM',
-    'MD',
-    'MC',
-    'MN',
-    'ME',
-    'MS',
-    'MA',
-    'MZ',
-    'MM',
-    'NA',
-    'NR',
-    'NP',
-    'NL',
-    'AN',
-    'NC',
-    'NZ',
-    'NI',
-    'NE',
-    'NG',
-    'NU',
-    'NF',
-    'MP',
-    'NO',
-    'OM',
-    'PK',
-    'PW',
-    'PS',
-    'PA',
-    'PG',
-    'PY',
-    'PE',
-    'PH',
-    'PN',
-    'PL',
-    'PT',
-    'PR',
-    'QA',
-    'RE',
-    'RO',
-    'RU',
-    'RW',
-    'BL',
-    'SH',
-    'KN',
-    'LC',
-    'MF',
-    'PM',
-    'VC',
-    'WS',
-    'SM',
-    'ST',
-    'SA',
-    'SN',
-    'RS',
-    'SC',
-    'SL',
-    'SG',
-    'SK',
-    'SI',
-    'SB',
-    'SO',
-    'ZA',
-    'GS',
-    'ES',
-    'LK',
-    'SD',
-    'SR',
-    'SJ',
-    'SZ',
-    'SE',
-    'CH',
-    'SY',
-    'TW',
-    'TJ',
-    'TZ',
-    'TH',
-    'TL',
-    'TG',
-    'TK',
-    'TO',
-    'TT',
-    'TN',
-    'TR',
-    'TM',
-    'TC',
-    'TV',
-    'UG',
-    'UA',
-    'AE',
-    'UM',
-    'UY',
-    'UZ',
-    'VU',
-    'VE',
-    'VN',
-    'VG',
-    'VI',
-    'WF',
-    'EH',
-    'YE',
-    'ZM',
-    'ZW',
-]);

package/dist/schemas/tier/index.d.ts

@@ -1,119 +0,0 @@
-import { infer, z } from "zod";
-export declare const planSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    slug: z.ZodString;
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        billingScheme: z.ZodEnum<["per_unit", "tiered"]>;
-        usageType: z.ZodNullable<z.ZodEnum<["metered", "licensed"]>>;
-        unitAmount: z.ZodNullable<z.ZodNumber>;
-        tiers: z.ZodArray<z.ZodObject<{
-            flatAmount: z.ZodNullable<z.ZodNumber>;
-            flatAmountDecimal: z.ZodNullable<z.ZodString>;
-            unitAmount: z.ZodNullable<z.ZodNumber>;
-            unitAmountDecimal: z.ZodString;
-            upTo: z.ZodNullable<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }, {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }>, "many">;
-        currency: z.ZodString;
-        interval: z.ZodEnum<["day", "week", "month", "year"]>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        unitAmount: number | null;
-        billingScheme: "per_unit" | "tiered";
-        usageType: "metered" | "licensed" | null;
-        tiers: {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }[];
-        currency: string;
-        interval: "day" | "week" | "month" | "year";
-    }, {
-        id: string;
-        unitAmount: number | null;
-        billingScheme: "per_unit" | "tiered";
-        usageType: "metered" | "licensed" | null;
-        tiers: {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }[];
-        currency: string;
-        interval: "day" | "week" | "month" | "year";
-    }>, "many">;
-    version: z.ZodNumber;
-    features: z.ZodArray<z.ZodString, "many">;
-    sortOrder: z.ZodNumber;
-    isActive: z.ZodBoolean;
-    createdAt: z.ZodDate;
-    archivedAt: z.ZodNullable<z.ZodDate>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    createdAt: Date;
-    name: string;
-    isActive: boolean;
-    sortOrder: number;
-    slug: string;
-    items: {
-        id: string;
-        unitAmount: number | null;
-        billingScheme: "per_unit" | "tiered";
-        usageType: "metered" | "licensed" | null;
-        tiers: {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }[];
-        currency: string;
-        interval: "day" | "week" | "month" | "year";
-    }[];
-    version: number;
-    features: string[];
-    archivedAt: Date | null;
-}, {
-    id: string;
-    createdAt: Date;
-    name: string;
-    isActive: boolean;
-    sortOrder: number;
-    slug: string;
-    items: {
-        id: string;
-        unitAmount: number | null;
-        billingScheme: "per_unit" | "tiered";
-        usageType: "metered" | "licensed" | null;
-        tiers: {
-            flatAmount: number | null;
-            flatAmountDecimal: string | null;
-            unitAmount: number | null;
-            unitAmountDecimal: string;
-            upTo: number | null;
-        }[];
-        currency: string;
-        interval: "day" | "week" | "month" | "year";
-    }[];
-    version: number;
-    features: string[];
-    archivedAt: Date | null;
-}>;
-export interface Plan extends infer<typeof planSchema> {
-}

package/dist/schemas/transaction/index.js

@@ -1,17 +0,0 @@
-import { number, object, string, z } from "zod";
-export const transactionTypeEnum = z.enum(["subscription", "add-on", "refund"]);
-export const transactionStatusEnum = z.enum([
-    "succeeded",
-    "failed",
-    "refunded",
-]);
-export const transactionSchema = object({
-    orgId: string(),
-    type: transactionTypeEnum,
-    creditsPurchased: number(),
-    creditsGranted: number().nullable(),
-    amountUsd: number(),
-    stripeInvoiceId: string(),
-    status: transactionStatusEnum,
-    timestamp: number(),
-});