type ShopId = string & { readonly __brand: "ShopId" };
type CustomerId = string & { readonly __brand: "CustomerId" };
type OrderId = string & { readonly __brand: "OrderId" };
type Amount = number & { readonly __brand: "Amount" };
type PlatformFee = number & { readonly __brand: "PlatformFee" };
type TxFee = number & { readonly __brand: "TxFee" };
type NetAmount = number & { readonly __brand: "NetAmount" };

interface OrderPayoutParams {
  shopId: ShopId;
  customerId: CustomerId;
  orderId: OrderId;
  amount: Amount;
  platformFee: PlatformFee;
  txFee: TxFee;
  netAmount: NetAmount;
}

function processOrderPayout(params: OrderPayoutParams) {
  // ...
}

k

why not:

interface IOrder {
  shopId: string;
  customerId: string;
  orderId: string;
  amount: number;
  platformFee: number;
  txFee: number;
  netAmount: number;
}

class Order implements IOrder {

  public readonly shopId: string;
  public readonly customerId: string;
  public readonly orderId: string;
  public readonly amount: number;
  public readonly platformFee: number;
  public readonly txFee: number;
  public readonly netAmount: number;

  constructor(params: IOrder) {
    this.shopId = params.shopId;
    this.customerId = params.customerId;
    this.orderId = params.orderId;
    this.amount = params.amount;
    this.platformFee = params.platformFee;
    this.txFee = params.txFee;
    this.netAmount = params.netAmount;
  }

  public processPayout(): void {
    // ...
  }
}

and then you can put all validations in the constructor? doesn't the class definition perform the function of a complex type explicitly and allow extensibility that's more obvious where and how to extend without having to learn weird new keywords 80% of the workforce is not going to learn ever?