Class and Object Helpers

/**
 * Ensure function is called with 'new' keyword
 * Helper name: "classCallCheck"
 */
function _classCallCheck(instance: any, Constructor: Function): void;

/**
 * Assert that 'this' is initialized in constructors
 * Helper name: "assertThisInitialized"
 */
function _assertThisInitialized<T>(self: T): T;

/**
 * Handle possible constructor return values
 * Helper name: "possibleConstructorReturn"
 */
function _possibleConstructorReturn<T>(self: T, call: any): T;

/**
 * Create class with method definitions
 * Helper name: "createClass"
 */
function _createClass(
  Constructor: Function,
  protoProps?: PropertyDescriptor[],
  staticProps?: PropertyDescriptor[]
): Function;

/**
 * Generic constructor helper
 * Helper name: "construct"
 */
function _construct<T extends any[], R>(
  Parent: new (...args: T) => R,
  args: T,
  Class?: new (...args: any[]) => any
): R;

/**
 * Set up class inheritance (standard mode)
 * Helper name: "inherits"
 */
function _inherits(subClass: Function, superClass: Function): void;

/**
 * Set up class inheritance (loose mode)
 * Helper name: "inheritsLoose"
 */
function _inheritsLoose(subClass: Function, superClass: Function): void;

/**
 * Class extension helper for extends keyword
 * Helper name: "extends"
 */
function _extends<T extends object, U extends object>(target: T, ...sources: U[]): T & U;

/**
 * Create super constructor helper
 * Helper name: "createSuper"
 */
function _createSuper<T extends Function>(Derived: T): Function;

/**
 * Call super constructor or method
 * Helper name: "callSuper"
 */
function _callSuper(
  t: any,
  o: Function,
  args?: any[]
): any;

/**
 * Get prototype of object
 * Helper name: "getPrototypeOf"
 */
function _getPrototypeOf(o: any): any;

/**
 * Set prototype of object
 * Helper name: "setPrototypeOf"
 */
function _setPrototypeOf(o: any, p: any): any;

/**
 * Wrap native super classes
 * Helper name: "wrapNativeSuper"
 */
function _wrapNativeSuper<T extends Function>(Class: T): T;

/**
 * Assert class brand for private fields (v2)
 * Helper name: "assertClassBrand"
 */
function _assertClassBrand(brand: WeakSet<object>, obj: object): void;

/**
 * Get private class field (v2)
 * Helper name: "classPrivateFieldGet2"
 */
function _classPrivateFieldGet2<T>(receiver: object, privateMap: WeakMap<object, T>): T;

/**
 * Set private class field (v2)
 * Helper name: "classPrivateFieldSet2"
 */
function _classPrivateFieldSet2<T>(
  receiver: object,
  privateMap: WeakMap<object, T>,
  value: T
): T;

/**
 * Initialize private field specification
 * Helper name: "classPrivateFieldInitSpec"
 */
function _classPrivateFieldInitSpec<T>(
  obj: object,
  privateMap: WeakMap<object, T>,
  value: T
): void;

/**
 * Initialize private method specification
 * Helper name: "classPrivateMethodInitSpec"
 */
function _classPrivateMethodInitSpec(obj: object, privateSet: WeakSet<object>): void;

/**
 * Private field loose mode base
 * Helper name: "classPrivateFieldLooseBase"
 */
function _classPrivateFieldLooseBase<T>(receiver: object, privateKey: symbol): T;

/**
 * Private field loose mode key
 * Helper name: "classPrivateFieldLooseKey"
 */
function _classPrivateFieldLooseKey(name: string): symbol;

/**
 * Private getter method
 * Helper name: "classPrivateGetter"
 */
function _classPrivateGetter<T>(privateMap: WeakMap<object, any>, receiver: object, fn: () => T): T;

/**
 * Private setter method
 * Helper name: "classPrivateSetter"
 */
function _classPrivateSetter<T>(
  privateMap: WeakMap<object, any>,
  receiver: object,
  fn: (value: T) => void,
  value: T
): void;

/**
 * Get static private method
 * Helper name: "classStaticPrivateMethodGet"
 */
function _classStaticPrivateMethodGet<T extends Function>(
  receiver: Function,
  classConstructor: Function,
  method: T
): T;

/**
 * Set static private method
 * Helper name: "classStaticPrivateMethodSet"
 */
function _classStaticPrivateMethodSet<T extends Function>(
  receiver: Function,
  classConstructor: Function,
  method: T,
  value: any
): void;

/**
 * Get static private field specification
 * Helper name: "classStaticPrivateFieldSpecGet"
 */
function _classStaticPrivateFieldSpecGet<T>(
  receiver: Function,
  classConstructor: Function,
  descriptor: { value: T }
): T;

/**
 * Set static private field specification
 * Helper name: "classStaticPrivateFieldSpecSet"
 */
function _classStaticPrivateFieldSpecSet<T>(
  receiver: Function,
  classConstructor: Function,
  descriptor: { value: T },
  value: T
): T;

/**
 * Check private redeclaration
 * Helper name: "checkPrivateRedeclaration"
 */
function _checkPrivateRedeclaration(obj: object, privateCollection: WeakMap<object, any> | WeakSet<object>): void;

/**
 * Apply descriptor destructure set for private fields
 * Helper name: "classApplyDescriptorDestructureSet"
 */
function _classApplyDescriptorDestructureSet(receiver: object, descriptor: PropertyDescriptor): PropertyDescriptor;

/**
 * Apply descriptor get for private fields
 * Helper name: "classApplyDescriptorGet"
 */
function _classApplyDescriptorGet(receiver: object, descriptor: PropertyDescriptor): any;

/**
 * Apply descriptor set for private fields
 * Helper name: "classApplyDescriptorSet"
 */
function _classApplyDescriptorSet(receiver: object, descriptor: PropertyDescriptor, value: any): void;

/**
 * Get private field using descriptor
 * Helper name: "classPrivateFieldGet"
 */
function _classPrivateFieldGet(receiver: object, privateMap: WeakMap<object, any>): any;

/**
 * Set private field using descriptor
 * Helper name: "classPrivateFieldSet"
 */
function _classPrivateFieldSet(receiver: object, privateMap: WeakMap<object, any>, value: any): any;

/**
 * Destructure set for private fields
 * Helper name: "classPrivateFieldDestructureSet"
 */
function _classPrivateFieldDestructureSet(receiver: object, privateMap: WeakMap<object, any>): PropertyDescriptor;

/**
 * Get private method
 * Helper name: "classPrivateMethodGet"
 */
function _classPrivateMethodGet(receiver: object, privateSet: WeakSet<object>): Function;

/**
 * Set private method
 * Helper name: "classPrivateMethodSet"
 */
function _classPrivateMethodSet(): never;

/**
 * Check private static access
 * Helper name: "classCheckPrivateStaticAccess"
 */
function _classCheckPrivateStaticAccess(receiver: Function, classConstructor: Function): void;

/**
 * Check private static field descriptor
 * Helper name: "classCheckPrivateStaticFieldDescriptor"
 */
function _classCheckPrivateStaticFieldDescriptor(descriptor: PropertyDescriptor, action: "get" | "set"): void;

/**
 * Extract field descriptor
 * Helper name: "classExtractFieldDescriptor"
 */
function _classExtractFieldDescriptor(receiver: object): PropertyDescriptor;

/**
 * Destructure set for static private fields
 * Helper name: "classStaticPrivateFieldDestructureSet"
 */
function _classStaticPrivateFieldDestructureSet(
  receiver: Function,
  classConstructor: Function,
  descriptor: PropertyDescriptor
): PropertyDescriptor;

/**
 * Set static private method
 * Helper name: "classStaticPrivateMethodSet"
 */
function _classStaticPrivateMethodSet(): never;

/**
 * Define object property
 * Helper name: "defineProperty"
 */
function _defineProperty<T extends object, K extends PropertyKey, V>(
  obj: T,
  key: K,
  value: V
): T & Record<K, V>;

/**
 * Define accessor property
 * Helper name: "defineAccessor"
 */
function _defineAccessor(
  obj: object,
  key: PropertyKey,
  get?: () => any,
  set?: (value: any) => void
): void;

/**
 * Define enumerable properties
 * Helper name: "defineEnumerableProperties"
 */
function _defineEnumerableProperties<T extends object, U extends Record<PropertyKey, PropertyDescriptor>>(
  target: T,
  properties: U
): T & U;

/**
 * Get property value
 * Helper name: "get"
 */
function _get(target: object, property: PropertyKey, receiver?: any): any;

/**
 * Set property value
 * Helper name: "set"
 */
function _set(target: object, property: PropertyKey, value: any, receiver?: any): boolean;

/**
 * Object defaults (assign defaults)
 * Helper name: "defaults"
 */
function _defaults<T extends object, U extends object>(obj: T, defaults: U): T & U;

/**
 * Super property base access
 * Helper name: "superPropBase"
 */
function _superPropBase(object: object, property: PropertyKey): any;

/**
 * Super property getter
 * Helper name: "superPropGet"
 */
function _superPropGet(
  target: object,
  property: PropertyKey,
  receiver: any,
  isStrict?: boolean
): any;

/**
 * Super property setter
 * Helper name: "superPropSet"
 */
function _superPropSet(
  target: object,
  property: PropertyKey,
  value: any,
  receiver: any,
  isStrict?: boolean
): boolean;

/**
 * Object destructuring empty check
 * Helper name: "objectDestructuringEmpty"
 */
function _objectDestructuringEmpty(obj: any): void;

/**
 * Object spread helper
 * Helper name: "objectSpread"
 */
function _objectSpread<T extends object>(...sources: T[]): T;

/**
 * Object spread helper (v2)
 * Helper name: "objectSpread2"
 */
function _objectSpread2<T extends object>(...sources: T[]): T;

/**
 * Object without properties (standard mode)
 * Helper name: "objectWithoutProperties"
 */
function _objectWithoutProperties<T extends object, K extends keyof T>(
  source: T,
  excluded: K[]
): Omit<T, K>;

/**
 * Object without properties (loose mode)
 * Helper name: "objectWithoutPropertiesLoose"
 */
function _objectWithoutPropertiesLoose<T extends object, K extends keyof T>(
  source: T,
  excluded: K[]
): Omit<T, K>;

/**
 * Convert value to primitive
 * Helper name: "toPrimitive"  
 */
function _toPrimitive(input: any, hint?: "string" | "number"): any;

/**
 * Convert to property key
 * Helper name: "toPropertyKey"
 */
function _toPropertyKey(arg: any): PropertyKey;

/**
 * Convert to setter function
 * Helper name: "toSetter"
 */
function _toSetter(fn: Function): (value: any) => void;

/**
 * Set function name
 * Helper name: "setFunctionName"
 */
function _setFunctionName<T extends Function>(fn: T, name: string, prefix?: string): T;

// These helpers are typically injected by Babel transforms
import { get } from "@babel/helpers";

// For class declarations: class MyClass extends Parent { }
const classHelper = get("createClass");
const extendsHelper = get("extends"); 
const inheritsHelper = get("inherits");
// Babel injects these helpers to handle class syntax

// For private fields: class C { #field = value; }
const privateFieldHelper = get("classPrivateFieldInitSpec");
const getPrivateHelper = get("classPrivateFieldGet2");
const setPrivateHelper = get("classPrivateFieldSet2");

// For object spread: const obj = { ...source };
const spreadHelper = get("objectSpread2");
// Babel injects: const obj = _objectSpread2({}, source);

// For destructuring: const { a, ...rest } = obj;
const withoutPropsHelper = get("objectWithoutProperties");
// Babel injects: const { a } = obj, rest = _objectWithoutProperties(obj, ["a"]);