3.9.3

README.md

@@ -1,4 +1,4 @@
-# Mod examples for v3.9.2
+# Mod examples for v3.9.3
 
 A collection of example mods that perform typical actions in SPT
 

TypeScript/10ScopesAndTypes/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/10ScopesAndTypes/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/11BundleLoadingSample/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/11BundleLoadingSample/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/12ClassExtensionOverride/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/12ClassExtensionOverride/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/13.1AddTraderWithAssortJSON/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/13.1AddTraderWithAssortJSON/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/13AddTrader/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/13AddTrader/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/14AfterDBLoadHook/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/14AfterDBLoadHook/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/15HttpListenerExample/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/15HttpListenerExample/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/16ImporterUtil/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/16ImporterUtil/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/17AsyncImporterWithDependency1/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/17AsyncImporterWithDependency1/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/17AsyncImporterWithDependency2/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/17AsyncImporterWithDependency2/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/18.1CustomItemServiceLootBox/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/18.1CustomItemServiceLootBox/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/18CustomItemService/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/18CustomItemService/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/19UseExternalLibraries/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/19UseExternalLibraries/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/1LogToConsole/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/1LogToConsole/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/20CustomChatBot/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/20CustomChatBot/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/21CustomCommandoCommand/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/21CustomCommandoCommand/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/22CustomAkiCommand/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/22CustomAkiCommand/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/2EditDatabase/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/2EditDatabase/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/3GetSptConfigFile/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/3GetSptConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/4.1UseACustomJson5OrJsonCConfigFile/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/4.1UseACustomJson5OrJsonCConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/4UseACustomConfigFile/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/4UseACustomConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/5ReplaceMethod/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/5ReplaceMethod/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/6ReferenceAnotherClass/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/6ReferenceAnotherClass/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/7OnLoadHook/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/7OnLoadHook/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/8OnUpdateHook/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/8OnUpdateHook/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;

TypeScript/9RouterHooks/types/generators/RagfairOfferGenerator.d.ts

@@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
      * @param items Items in the offer
      * @param barterScheme Cost of item (currency or barter)
      * @param loyalLevel Loyalty level needed to buy item
-     * @param sellInOnePiece Set StackObjectsCount to 1
+     * @param isPackOffer Is offer being created flaged as a pack
      * @returns IRagfairOffer
      */
-    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
+    protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
     /**
      * Create the user object stored inside each flea offer object
      * @param userID user creating the offer

TypeScript/9RouterHooks/types/models/eft/ragfair/IRagfairOffer.d.ts

@@ -9,23 +9,20 @@ export interface IRagfairOffer {
     intId: number;
     /** Handbook price */
     itemsCost: number;
-    /** Rouble price */
+    /** Rouble price per item */
     requirementsCost: number;
     startTime: number;
     endTime: number;
     sellInOnePiece: boolean;
+    /** Rouble price - same as requirementsCost */
+    summaryCost: number;
+    user: IRagfairOfferUser;
+    /** Trader only */
+    unlimitedCount?: boolean;
     loyaltyLevel: number;
     buyRestrictionMax?: number;
     buyRestrictionCurrent?: number;
-    locked: boolean;
+    locked?: boolean;
-    unlimitedCount: boolean;
-    /** Rouble price */
-    summaryCost: number;
-    user: IRagfairOfferUser;
-    notAvailable: boolean;
-    /** TODO - implement this value - not currently used */
-    CurrentItemCount: number;
-    priority: boolean;
 }
 export interface OfferRequirement {
     _tpl: string;
@@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
     nickname?: string;
     rating?: number;
     memberType: MemberCategory;
+    selectedMemberCategory?: MemberCategory;
     avatar?: string;
     isRatingGrowing?: boolean;
     aid?: number;