For me, I found that switching from using interface to type was the solution.

To specify the type of index for TS, we need to inform the compiler about how we want to index the object. For instance, if we want to allow indexing with any string like myObj['anyString'], we can modify the code from:

interface MyInterface {
  myVal: string;
}

to:

interface MyInterface {
  [key: string]: string;
  myVal: string;
}

Now, you are able to assign any string value to any string index as shown below:

x['myVal'] = 'hello world'
x['any other string'] = 'any other string'

Check out the interactive example on the Playground Link.

Switching from interface to type resolved the issue for me.

This problem may arise if the function foo is expecting a parameter with type instead of interface, like so:

type MyType = {
   dic: { [name: string]: number }
}

function foo(a: MyType) {}

When passing a value typed with an interface, such as:

interface MyInterface {
    dic: { [name: string]: number }
}

const o: MyInterface = {
    dic: {
        'a': 3,
        'b': 5
    }
}

foo(o) // error occurs here

I simply changed it to:

const o: MyType = {
    dic: {
        'a': 3,
        'b': 5
    }
}

foo(o) // It now works perfectly

To tackle this issue, simply execute foo({...o}) sandbox

Allow me to share my perspective:

interface Duplicate<U> = { [V in keyof U]: U[V] }

customFunction<DifferentType>() // Absence of index signature

customFunction<Duplicate<DifferentType>>() // No issue

The issue extends beyond the original question posed by OP.

Consider this scenario where we define an interface and a variable of that interface:

interface IObj {
  prop: string;
}

const obj: IObj = { prop: 'string' };

Can we assign obj to type Record<string, string>?

The answer is No. Demo

// TS2322: Type 'IObj' is not assignable to type 'Record<string, string>'. Index signature for type 'string' is missing in type 'IObj'.
const record: Record<string, string> = obj; 

Why does this happen? To explain, let's revisit our understanding of "upcasting" and "downcasting", as well as the significance of the "L" letter in SOLID principles.

The following examples do not result in errors because we are assigning a broader type to a more specific one.

Demo

const initialObj = {
  title: 'title',
  value: 42,
};

interface IObj {
  title: string;
}

const obj: IObj = initialObj; // No error here

obj.title;
obj.value; // Property 'value' does not exist on type 'IObj'.(2339)

IObj only requires one property, so the assignment is valid.

A similar concept applies to Types. Demo

const initialObj = {
  title: 'title',
  value: 42,
};

type TObj = {
  title: string;
}

const obj: TObj = initialObj; // No error here

obj.title;
obj.value; // Property 'value' does not exist on type 'TObj'.(2339)

The absence of errors in the last two examples is due to the concept of "upcasting", where a value type is cast to a higher type (an ancestor entity). You can assign Dog to Animal, but not the other way around (Refer to the meaning of "L" in SOLID principles). Assigning from Dog to Animal represents "upcasting", which is considered a safe operation.

Record<string, string> is much broader than an object with just one property, as it allows for additional properties.

const fn = (record: Record<string, string>) => {
  record.value1;
  record.value2;
  record.value3; // No errors here
}

Thus, when you attempt to assign the IObj Interface to Record<string, string>, an error occurs. The assignment should be made to a type that extends IObj. The Record<string, string> type can be a subclass of IObj.

In other responses, suggestions may include using a Type to resolve the issue. However, this might not be the correct approach, and it's advisable to avoid such constructs.

This issue raises pertinent questions in this context, along with an insightful related comment.

This issue is completely valid. Consider using one of the following options:

const obj = Object.freeze({dictionary: {'a': 3, 'b': 5}})
const obj = {dictionary: {'a': 3, 'b': 5}} as const
const obj: MyCustomInterface = {dictionary: {'a': 3, 'b': 5}}

Why is this necessary?

The TypeScript compiler cannot assume that the object referenced by obj remains unchanged from its initialization to when foo(obj) is invoked.

It's possible that elsewhere in your code, there could be a snippet like this:

delete obj.dictionary

This explains why the inline version is effective, as it eliminates any potential updates.

Here's a helpful little trick that you might find handy:

interface ConvertInterfaceToDictionary<T> = {
  [Key in keyof T]: T[Key];
};

This conversion really came to my rescue and resolved the problem I was facing:

The error 'Argument of type 'QueryParameters' is not assignable to parameter of type 'Record<string, string>' kept popping up.

The issue stemmed from QueryParameters being an Interface that couldn't be directly modified since it originated from a third-party package.

This appears to be the top search result for that specific query. In cases where you have an index type already set as (string, string) and cannot modify the type of input, there is an alternative approach:

foo({...o}) // Enchantment

To address your inquiry, another method to accomplish this is as follows:

interface NewInterface {
    [name: string]: number
}

function bar(b: NewInterface) {
    ...
}

let p = {
   'x': 8,
   'y': 10
}

bar(p);

Although the error no longer appears in our specific scenario, there are still instances where it persists:

function foo(a: { [name: string]: number }) {
}

interface Test {
    test: number;
}

const test: Test = { test: 1 };
foo(test); // Error

The main cause of this error seems to be that an interface can be extended through declaration merging, resulting in the possibility of additional properties being added to the interface that do not correspond to the number type. This explains why changing [name: string]: any removes the error (despite the error message focusing on the key rather than the value).

Options for resolving this issue, as highlighted in previous responses and TypeScript issue #15300, include:

• Using type Test instead of interface Test – Prevents declaration merging and resolves the problem.
• Utilizing

  const test: Pick<Test, keyof Test>

• Applying foo({ ...test })

However, none of these solutions are universally applicable. For instance, situations involving nested interfaces from third-party libraries may require a different approach.

To address this more broadly, a helper type like the following can be useful:

type InterfaceToType<T> = {
    [K in keyof T]: InterfaceToType<T[K]>;
}

const test: InterfaceToType<Test> = { test: 1 };
foo(test);

If the change from using interface to type did not work, you can try this alternative solution using type that worked for me:

type MyInterface {
    dictionary: { [name: string]: number } | {};
}

function foo(a: MyInterface) {
    ...
}

let obj = {
    dictionary: {
        'a': 3,
        'b': 5
    }
}

foo(obj);

Resolution: Opt for Type over Interface

Scenario:

interface GenericDictionary {
  [key: string]: SpecificDataType;
}

export class MyCustomClass<SpecificDictionary extends GenericDictionary = GenericDictionary> {

  private readonly dictionary = {} as SpecificDictionary;

  constructor(keys: (keyof SpecificDictionary)[]) {
    for (const key of keys) {
      this.dictionary[key] = //... some value as SpecificDataType ;
    }
  }
}

Ineffective Approach:

interface MyDictionary {
  myKey1: SpecificDataType;
  myKey2: SpecificDataType;
}

const customObject = new MyCustomClass<MyDictionary>('myKey1', 'myKey2');

// TS2344: Type MyDictionary does not adhere to the constraint GenericDictionary
Index signature for type string is missing in type MyDictionary

Functional but Lacks Type Safety:

interface MyDictionary {
  [key: string]: SpecificDataType;
  myKey1: SpecificDataType;
  myKey2: SpecificDataType;
}

const customObject = new MyCustomClass<MyDictionary>('myKey1', 'myKey2', 'someExtraKey');

// 'someExtraKey' gets accepted despite not being valid

Resolution:

type MyDictionary = {
  myKey1: SpecificDataType;
  myKey2: SpecificDataType;
}

const customObject = new MyCustomClass<MyDictionary>('myKey1', 'myKey2');

// functions properly and restricts random keys

For further details on index signatures, visit: