Update configuration.mdx based on issue #266

Author: kgowru

fern/products/sdks/overview/typescript/configuration.mdx

@@ -130,9 +130,11 @@ Specify extra peer dependencies meta fields in the generated `package.json`:
 ```yaml
 # generators.yml
 config:
-  extraPeerDependencies:
-    react: ">=16.8.0 <19.0.0"
-    "react-dom": ">=16.8.0 <19.0.0"
+  extraPeerDependenciesMeta:
+    react:
+      optional: true
+    "react-dom":
+      optional: true
 ```
 </ParamField>
 
@@ -411,134 +413,44 @@ generate a `jsr.json` as well as a GitHub workflow to publish to JSR.
 
 </ParamField>
 
-<ParamField path="shouldGenerateWebsocketClients" type="boolean" toc={true}>
-	Generate WebSocket clients from your AsyncAPI specs.
-</ParamField>
-
-<ParamField path="skipResponseValidation" type="boolean" default="false" toc={true}>
- By default, the client will throw an error if the response from the server
-doesn't match the expected type (based on how the response is modeled in the
-Fern Definition).
-
-If `skipResponseValidation` is set to `true`, the client will never throw if the response is misshapen. Instead, the client will log the issue using `console.warn` and return the data (casted to the expected response type).
-
-<Warning>Response validation only occurs when the Serde layer is enabled (`noSerdeLayer: false`). The Serde layer is disabled by default (`noSerdeLayer: true`).</Warning>
-
-</ParamField>
-
-<ParamField path="streamType" type="'wrapper' | 'web'" toc={true}>
-Change the type of stream that is used in the generated SDK.
-
-*    `wrapper`: The streams use a wrapper with multiple underlying implementations to support versions of Node.js before Node.js 18.
-*    `web`: The streams use the web standard `ReadableStream`.
-
-The default is `web`.
-</ParamField>
-
-<ParamField path="treatUnknownAsAny" type="boolean" default="false" toc={true}>
-  When `treatUnknownAsAny` is enabled, [unknown types from Fern are generated into TypeScript using `any` instead of the `unknown` type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#new-unknown-top-type).
-</ParamField>
-
-<ParamField path="useBigInt" type="boolean" default="false" toc={true}>
-When `useBigInt` is set to `true`, a customized JSON serializer & deserializer is used that will preserve the precision of `bigint`'s, as opposed to the native `JSON.stringify` and `JSON.parse` function which converts `bigint`'s to number's losing precision.
-
-When combining `useBigInt` with our serialization layer (`no-serde: false`), both the request and response properties that are marked as `long` and `bigint` in OpenAPI/Fern spec, will consistently be `bigint`'s.
-However, when disabling the serialization layer (`no-serde: true`), they will be typed as `number | bigint`.
+<ParamField path="sdkVariables" type="Record<string, boolean>" toc={true}>
+Configures SDK variables that can be set at client initialization time and will be injected into endpoints when needed. Each variable name maps to a boolean indicating whether it is required.
 
-Here's an overview of what to expect from the generated types when combining `useBigInt` and `noSerde` with the following Fern definition:
+```yaml
+# generators.yml
+config:
+  sdkVariables:
+    project_id: true  # Required variable
+    tenant_id: false  # Optional variable
+```
 
-*Fern definition*:
+The variables will be injected into endpoints based on their declaration in your OpenAPI or Fern definition (via `x-fern-sdk-variables`). For example:
 
 ```yaml
-types:
-  ObjectWithOptionalField:
-    properties:
-      longProp: long
-      bigIntProp: bigint
+# OpenAPI
+x-fern-sdk-variables:
+  project_id:
+    type: string
+    description: "The project ID to use"
+    pattern: "^proj_[a-zA-Z0-9]+$"
 ```
 
-*TypeScript output*:
+Generated client:
 
 ```typescript
-// useBigInt: true
-// noSerde: false
-interface ObjectWithLongAndBigInt {
-  longProp: bigint;
-  bigIntProp: bigint;
-}
-
-// useBigInt: true
-// noSerde: true
-interface ObjectWithLongAndBigInt {
-  longProp: bigint | number;
-  bigIntProp: bigint | number;
-}
-
-// useBigInt: false
-// noSerde: false
-interface ObjectWithLongAndBigInt {
-  longProp: number;
-  bigIntProp: string;
-}
-
-// useBigInt: false
-// noSerde: true
-interface ObjectWithLongAndBigInt {
-  longProp: number;
-  bigIntProp: string;
-}
+const client = new Client({
+  // Required variable 
+  project_id: "proj_123",
+  // Optional variable
+  tenant_id: "tenant_456" 
+});
 ```
 </ParamField>
 
-<ParamField path="useBrandedStringAliases" type="boolean" default="false" toc={true}>
-
-	When `useBrandedStringAliases` is disabled (the default), string aliases are generated as
-	normal TypeScript aliases:
-
-	```typescript
-	// generated code
-
-	export type MyString = string;
-
-	export type OtherString = string;
-	```
-  When `useBrandedStringAliases` is enabled, string aliases are generated as branded strings. This makes each alias feel like its own type and improves compile-time safety.
-
-	```yaml
-	# fern definition
-
-	types:
-		MyString: string
-		OtherString: string
-	```
-
-	```typescript
-	// generated code
-
-	export type MyString = string & { __MyString: void };
-	export const MyString = (value: string): MyString => value as MyString;
-
-	export type OtherString = string & { __OtherString: void };
-	export const OtherString = (value: string): OtherString => value as OtherString;
-	```
-
-	```typescript
-	// consuming the generated type
-
-	function printMyString(s: MyString): void {
-	  console.log("MyString: " + s);
-	}
-
-	// doesn't compile, "foo" is not assignable to MyString
-	printMyString("foo");
-
-	const otherString = OtherString("other-string");
-	// doesn't compile, otherString is not assignable to MyString
-	printMyString(otherString);
-
-	// compiles
-	const myString = MyString("my-string");
-	printMyString(myString);
-	```
+<ParamField path="shouldGenerateWebsocketClients" type="boolean" toc={true}>
+	Generate WebSocket clients from your AsyncAPI specs.
+</ParamField>
 
-</ParamField>
+<ParamField path="skipResponseValidation" type="boolean" default="false" toc={true}>
+ By default, the client will throw an error if the response from the server
+doesn't match the expected type (based on how