# TS1348: Non-simple parameter declared here

# TS1348: Non-simple parameter declared here

TypeScript is a typed superset of JavaScript that aims to enhance the development experience by adding static types to the language. This means that you can define the types of variables, function parameters, return values, and more, which helps catch errors at compile time rather than runtime. Types in TypeScript are annotations that specify what kind of data you are working with, enabling better tooling and documentation.

For those interested in deepening their understanding of TypeScript, I highly recommend subscribing to my blog for more insights. Additionally, you can use [gpteach](https://gpteach.us) to learn how to code effectively using AI tools.

## What Are Enums?

Enums (short for enumerations) are a feature in TypeScript that allows you to define a set of named constants. This can be particularly useful for representing a group of related values. For example, you might want an enum to describe different status codes:

```typescript
enum Status {
    Active,
    Inactive,
    Suspended,
}
```

In this example, `Status` is an enum with three possible values: `Active`, `Inactive`, and `Suspended`. Enums help you work with these sets of constants in a more readable and maintainable way.

---

Now, let's delve into the error known as **TS1348: Non-simple parameter declared here**. This error typically occurs when TypeScript encounters a function parameter that cannot be easily resolved due to its complex type definition.

### Understanding TS1348: Non-simple parameter declared here

The **TS1348: Non-simple parameter declared here** error arises when you declare a function with a parameter whose type is either a union of more complex types or involves generic types that could introduce ambiguity.

Here's an example that would trigger the **TS1348: Non-simple parameter declared here** error:

```typescript
type StringOrNumber = string | number;

function doSomething(value: StringOrNumber[]) {
    // Function implementation
}
```

In this code, the parameter `value` is declared as an array of a union type. This can confuse TypeScript since it’s not a "simple" type (like `string`, `number`, or `boolean`). To resolve the **TS1348: Non-simple parameter declared here** error, you can simplify your parameter type:

### How to Fix TS1348: Non-simple parameter declared here

A common approach is to split the complex union types into simpler constructs. Here’s how you can adjust the function:

```typescript
function doSomething(value: Array<string | number>) {
    // Function implementation
}
```

By explicitly stating that you're using an `Array` type, you provide TypeScript more clarity.

### Important to Know!
- **Type definitions** should be as clear and straightforward as possible to prevent ambiguity.
- Always favor simple types over complex unions when declaring parameters to avoid errors like **TS1348: Non-simple parameter declared here**.

### Example of a Real-World Fix

Consider an API function that receives either user IDs (as numbers) or usernames (as strings):

```typescript
type UserIdentifier = string | number;

function getUserInfo(user: UserIdentifier) {
    // Implementation
}
```

To fix the **TS1348: Non-simple parameter declared here** error, separate out your parameters:

```typescript
function getUserInfoByID(userId: number): void;
function getUserInfoByUsername(username: string): void;

function getUserInfo(user: UserIdentifier): void {
    // Implementation
}
```

This restructuring clarifies the parameter types and keeps TypeScript from raising the **TS1348: Non-simple parameter declared here** error.

### FAQs

**Q1: What causes TS1348: Non-simple parameter declared here?**
- It’s caused by declaring function parameters with complex or ambiguous types.

**Q2: How can I avoid this error in my TypeScript code?**
- Use simpler and clearer type definitions for your function parameters.

**Q3: Can my TypeScript project handle complex types?**
- Yes, but remember that clarity is key; use clear definitions and avoid unnecessary complexity.

### Important Things to Know

1. **Type Clarity**: Always strive for clear type definitions to prevent errors.
2. **Simplicity**: Prefer simpler types over complex types in function parameters.
3. **Modular Functions**: Break down your functions to ensure parameters remain simple.

By understanding and addressing the **TS1348: Non-simple parameter declared here** error, you can write cleaner, more maintainable TypeScript code. Always remember that simplicity in type definitions will lead to fewer headaches in your TypeScript journey!