@@ -452,9 +452,10 @@ let response = await sdk.ok(sdk.${method.name}(`;
         params.length > 0 ? `\n${params.join(this.paramDelimiter)}` : '';
     }
     const callback = `callback: (response: Response) => Promise<${mapped.name}>,`;
+    const generics = streamer ? '' : this.methodGenericParams(method);
     const header =
       this.commentHeader(indent, headComment) +
-      `${indent}async ${method.name}(` +
+      `${indent}async ${method.name}${generics}(` +
       (streamer ? `\n${bump}${callback}` : '');
     const returns = streamer ? '' : `: ${this.returnType(indent, method)}`;
 
@@ -495,15 +496,53 @@ let response = await sdk.ok(sdk.${method.name}(`;
     );
   }
 
+  /**
+   * Methods whose declared response type is a generic `string` but whose
+   * actual runtime shape depends on a `result_format` request parameter
+   * (e.g. 'json' returns a parsed object/array, not a string). The Looker
+   * API spec does not document per-format response shapes, so these are
+   * special-cased here to expose a generic type parameter instead of the
+   * inaccurate hardcoded `string` return type.
+   *
+   * See https://github.com/looker-open-source/sdk-codegen/issues/1703
+   */
+  private static readonly formatDependentStringMethods = new Set([
+    'run_inline_query',
+  ]);
+
+  /**
+   * `true` if this method should expose a `<T = string>` generic instead of
+   * a hardcoded `string` return type
+   */
+  hasGenericResponse(method: IMethod): boolean {
+    return TypescriptGen.formatDependentStringMethods.has(method.name);
+  }
+
+  /**
+   * The generic type parameter declaration to splice between a method's
+   * name and its parameter list, or '' if the method has no generic response
+   */
+  methodGenericParams(method: IMethod): string {
+    return this.hasGenericResponse(method) ? '<T = string>' : '';
+  }
+
+  /**
+   * The name to use for the method's response type, honoring the generic
+   * response override for format-dependent methods
+   */
+  responseTypeName(method: IMethod): string {
+    if (this.hasGenericResponse(method)) return 'T';
+    return this.typeMap(method.type).name;
+  }
+
   /**
    * Return type declaration for the method
    * @param indent
    * @param method
    */
   returnType(indent: string, method: IMethod): string {
-    const mapped = this.typeMap(method.type);
     const errors = this.errorResponses(indent, method);
-    return `Promise<SDKResponse<${mapped.name}, ${errors}>>`;
+    return `Promise<SDKResponse<${this.responseTypeName(method)}, ${errors}>>`;
   }
 
   customHeaderComment(term: string, method: IMethod, params: string[] = []) {
@@ -652,9 +691,10 @@ ${indent}})`;
       fragment =
         params.length > 0 ? `\n${params.join(this.paramDelimiter)}` : '';
     }
+    const generics = this.methodGenericParams(method);
     const header =
       this.commentHeader(indent, headComment) +
-      `${indent}export const ${method.name} = async (`;
+      `${indent}export const ${method.name} = async ${generics}(`;
     const returns = this.returnType(indent, method);
 
     return (
@@ -839,13 +879,12 @@ ${indent}})`;
 
   httpCall(indent: string, method: IMethod) {
     const request = this.useRequest(method) ? 'request.' : '';
-    const mapped = this.typeMap(method.type);
     const bump = this.bumper(indent);
     const args = this.httpArgs(bump, method);
     const errors = this.errorResponses(indent, method);
     return (
       `${indent}return ${this.it(method.httpMethod.toLowerCase())}` +
-      `<${mapped.name}, ${errors}>(` +
+      `<${this.responseTypeName(method)}, ${errors}>(` +
       this.httpPath(method.endpoint, request) +
       `${args ? ', ' + args : ''})`
     );
 
@@ -11268,13 +11268,13 @@ export const run_query = async (
  * @param options one-time API call overrides
  *
  */
-export const run_inline_query = async (
+export const run_inline_query = async <T = string>(
   sdk: IAPIMethods,
   request: IRequestRunInlineQuery,
   options?: Partial<ITransportSettings>
-): Promise<SDKResponse<string, IError | IValidationError>> => {
+): Promise<SDKResponse<T, IError | IValidationError>> => {
   request.result_format = encodeParam(request.result_format);
-  return sdk.post<string, IError | IValidationError>(
+  return sdk.post<T, IError | IValidationError>(
     `/queries/run/${request.result_format}`,
     {
       limit: request.limit,
 
@@ -10588,12 +10588,12 @@ export class Looker40SDK extends APIMethods implements ILooker40SDK {
    * @param options one-time API call overrides
    *
    */
-  async run_inline_query(
+  async run_inline_query<T = string>(
     request: IRequestRunInlineQuery,
     options?: Partial<ITransportSettings>
-  ): Promise<SDKResponse<string, IError | IValidationError>> {
+  ): Promise<SDKResponse<T, IError | IValidationError>> {
     request.result_format = encodeParam(request.result_format);
-    return this.post<string, IError | IValidationError>(
+    return this.post<T, IError | IValidationError>(
       `/queries/run/${request.result_format}`,
       {
         limit: request.limit,
 
@@ -7469,10 +7469,10 @@ export interface ILooker40SDK extends IAPIMethods {
    * @param options one-time API call overrides
    *
    */
-  run_inline_query(
+  run_inline_query<T = string>(
     request: IRequestRunInlineQuery,
     options?: Partial<ITransportSettings>
-  ): Promise<SDKResponse<string, IError | IValidationError>>;
+  ): Promise<SDKResponse<T, IError | IValidationError>>;
 
   /**
    * ### Run an URL encoded query.