type SomethingAlias = number | string
 
interface SomethingShape {
	nickName: string;
	level: number;
} //형태가 온다.

type Sushi = {
	calories: number;
	salty: boolean;
	price: number;
}

 interface Sushi {
 	calories: number
	salty: boolean
	price: number
}
 
const unagiSushi: Sushi = {
	calories: 11
	salty: 15;
	price: 20
}

type Cake = {
	calories: number
	sweet: boolean
  price: boolean
}

type Food = {
	calories: number
	price: number
}
 
type Sushi = Food & {
	salty: boolean
}
 
type Cake = Food & {
 sweet: boolean
}

interface Food {
	calories: number
	price: number
}
 
interface Sushi extends Food {
	salty: boolean
}
 
interface Cake extends Food {
 sweet: boolean

interface A {
	getString(x: number): string
	getNumber(x: number): number
}
 
interface B extends A {
	getString(x: string | number): string // OK (number가 할당될 수 있음)
	getNumber(x: string): string // error
}

Interface 'B' incorrectly extends interface 'A'.
  Types of property 'getNumber' are incompatible.
    Type **'(x: string) => string' is not assignable to type '(x: number) => number'.**
      Types of parameters 'x' and 'x' are incompatible.
        Type **'number' is not assignable to type 'string' 
   => A 인터페이스의 nubmer 타입 파라미터가 B 인터페이스의 string 타입 파라미터에 할당될 수 없음을 경고.**

type A = {
	getString(x: number): string
	getNumber(x: number): number
}
 
type B = A & {
	getString(x: string | number): string 
	getNumber(x: string): string
}

interface User {
	name: string
}
 
interface User {
	age: number
}
 
interface User {
	email: string
}
 
const elice: User = {
	name: 'elice',
	age: 8,
	email: 'elice@elicer.com'
}

interface User {
	name: string;
}
 
interface User {
	name: string | boolean; 
// Error: Subsequent property declarations must have the same type. 
// Property 'name' must be of type 'string', but here has type 'boolean'.(2717)
// input.tsx(32, 2): 'name' was also declared here.
}

interface User<Name extends string>{
	name: Name;
}
 
interface User<Name extends boolean>{
	name: Name;
} 
// All declarations of 'User' must have identical type parameters

interface MyInterface<T> {
  prop1: T;
}
 
interface MyInterface<T> {
  prop2: T;
}
 
const obj: MyInterface<string> = {
  prop1: "Hello",
  prop2: "World",
};

interface Developer {
	name: string;
	language: string[];
	sleep(hours: number): void;
	work(hours: number): void;
}
 
class EliceDeveloper implements Developer {
		name: 'elicer'
		language: ['TypeScript', 'JavaScript', 'Python']
		sleep(hours: number) {
			console.log(`Slept for ${hours} hours`);
			if (hours > 10) console.log('you are late!! wake up!')
		}
		work(hours: number) {
			console.log(`worked for ${hours} hours`);
			if (hours > 13) console.log('you can take a taxi onn your way home from work.')
		}
		
}

enum Project {
	landing,
	LXP,
	test,
	works,
	designSystem,
	admin,
	account
}
 
interface PlatformTeam {
	squad: string;
	project: Project;
}
 
class EliceDeveloper implements Developer, PlatformTeam {
	name = 'elicer'
	language= ['TypeScript', 'JavaScript', 'Python']
	sleep(hours: number) {
		console.log(`Slept for ${hours} hours`);
		if (hours > 10) console.log('you are late!! wake up!')
	}
	work(hours: number, /*hasHotfix: boolean */) {
		console.log(`worked for ${hours} hours`);
		if (hours > 13) console.log('you can take a taxi onn your way home from work.')
	}
	// PlatformTeam 구현 프로퍼티
	squad = 'Web B'
	project = Project.designSystem
	// 추가한 메서드와 프로퍼티.
	deploy(issueCount: number ) {
		issueCount < 3 ?  console.log('칼퇴') : console.log('야근')
	}
}

interface Person {
  name: string;
  age: number;
}

type StringOrNumber = string | number;

class Javascript {
	write() {
	// ...
	}
}
 
class TypeScript {
	write()
}
	
// JavaScript class 타입을 매개변수로 받는 함수
const develop = (language: Javascript) => {
	language.write()
}
 
const typescript = new TypeScript;
 
develop(typescript); // OK

class A {
	private age = 30
}
 
class AB extends A {}
 
const run = (person: A) => {
}
 
run(new A) // OK
run(new AB) // OK
run({age: 30}) // error

export interface ChipPropsVariantOverrides {}
 
export interface ChipPropsSizeOverrides {}
 
export interface ChipPropsColorOverrides {}
 
export interface ChipTypeMap<P = {}, D extends React.ElementType = 'div'> {
  props: P & {
    /**
     * The Avatar element to display.
     */
    avatar?: React.ReactElement;
    /**
     * This prop isn't supported.
     * Use the `component` prop if you need to change the children structure.
     */
    children?: null;
    /**
     * Override or extend the styles applied to the component.
     */
    classes?: Partial<ChipClasses>;
    /**
     * If `true`, the chip will appear clickable, and will raise when pressed,
     * even if the onClick prop is not defined.
     * If `false`, the chip will not appear clickable, even if onClick prop is defined.
     * This can be used, for example,
     * along with the component prop to indicate an anchor Chip is clickable.
     * Note: this controls the UI and does not affect the onClick event.
     */
    clickable?: boolean;
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).
     * @default 'default'
     */
    **color?: OverridableStringUnion<
      'default' | 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning',
      ChipPropsColorOverrides
    >;**
    /**
     * Override the default delete icon element. Shown only if `onDelete` is set.
     */
    deleteIcon?: React.ReactElement;
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled?: boolean;
    /**
     * Icon element.
     */
    icon?: React.ReactElement;
    /**
     * The content of the component.
     */
    label?: React.ReactNode;
    /**
     * Callback fired when the delete icon is clicked.
     * If set, the delete icon will be shown.
     */
    onDelete?: React.EventHandler<any>;
    /**
     * The size of the component.
     * @default 'medium'
     */
    **size?: OverridableStringUnion<'small' | 'medium', ChipPropsSizeOverrides>;**
   /**
     * If `true`, allows the disabled chip to escape focus.
     * If `false`, allows the disabled chip to receive focus.
     * @default false
     */
    skipFocusWhenDisabled?: boolean;
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx?: SxProps<Theme>;
    /**
     *  @ignore
     */
    tabIndex?: number;
    /**
     * The variant to use.
     * @default 'filled'
     */
    **variant?: OverridableStringUnion<'filled' | 'outlined', ChipPropsVariantOverrides>;**
  };
  defaultComponent: D;
}
 
export type ChipProps<
  D extends React.ElementType = ChipTypeMap['defaultComponent'],
  P = {},
> = OverrideProps<ChipTypeMap<P, D>, D>;
 

**declare module '@mui/material/Button' {// module augmentation**
	interface **ChipPropsVariantOverrides {
		muted: true;
	}
 
  interface {
 
  }
}**