@contractkit/plugin-csharp 0.0.0

package/.turbo/turbo-build$colon$ci.log

@@ -0,0 +1,13 @@
+$ eslint --max-warnings=0 && pnpm run build
+$ tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: esnext
+ESM Build start
+ESM dist/index.js     93.08 KB
+ESM dist/index.js.map 198.91 KB
+ESM ⚡️ Build success in 28ms
+DTS Build start
+DTS ⚡️ Build success in 419ms
+DTS dist/index.d.ts 1.50 KB

package/.turbo/turbo-build.log

@@ -0,0 +1,12 @@
+$ tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: esnext
+ESM Build start
+ESM dist/index.js     93.08 KB
+ESM dist/index.js.map 198.91 KB
+ESM ⚡️ Build success in 19ms
+DTS Build start
+DTS ⚡️ Build success in 299ms
+DTS dist/index.d.ts 1.50 KB

package/.turbo/turbo-format.log

@@ -0,0 +1,34 @@
+$ prettier --write .
+CHANGELOG.md 9ms (unchanged)
+dist/codegen-client.d.ts 22ms
+dist/codegen-models.d.ts 7ms
+dist/codegen-sdk.d.ts 1ms
+dist/hoist.d.ts 5ms
+dist/index.d.ts 3ms
+dist/index.js 97ms
+dist/naming.d.ts 6ms
+dist/runtime-converters.d.ts 1ms
+dist/runtime.d.ts 1ms
+dist/scaffold.d.ts 2ms
+eslint.config.js 1ms (unchanged)
+package.json 2ms (unchanged)
+README.md 20ms
+src/codegen-client.ts 37ms
+src/codegen-models.ts 40ms
+src/codegen-sdk.ts 3ms (unchanged)
+src/hoist.ts 17ms (unchanged)
+src/index.ts 13ms (unchanged)
+src/naming.ts 5ms (unchanged)
+src/runtime-converters.ts 1ms (unchanged)
+src/runtime.ts 1ms (unchanged)
+src/scaffold.ts 1ms (unchanged)
+tests/codegen-client.test.ts 13ms
+tests/codegen-models.test.ts 32ms
+tests/helpers.ts 8ms (unchanged)
+tests/hoist.test.ts 6ms (unchanged)
+tests/index.test.ts 6ms
+tests/naming.test.ts 4ms (unchanged)
+tests/runtime.test.ts 2ms (unchanged)
+tests/scaffold.test.ts 1ms (unchanged)
+tsconfig.json 1ms (unchanged)
+vitest.config.ts 1ms (unchanged)

package/.turbo/turbo-test.log

@@ -0,0 +1,17 @@
+$ vitest run
+
+ RUN  v4.1.5 /Users/robert/projects/ContractKit/packages/plugin-csharp
+
+ ✓ tests/scaffold.test.ts (5 tests) 1ms
+ ✓ tests/naming.test.ts (19 tests) 2ms
+ ✓ tests/runtime.test.ts (14 tests) 2ms
+ ✓ tests/hoist.test.ts (10 tests) 2ms
+ ✓ tests/codegen-client.test.ts (26 tests) 5ms
+ ✓ tests/codegen-models.test.ts (63 tests) 6ms
+ ✓ tests/index.test.ts (10 tests) 7ms
+
+ Test Files  7 passed (7)
+      Tests  147 passed (147)
+   Start at  09:19:55
+   Duration  213ms (transform 426ms, setup 0ms, import 716ms, tests 25ms, environment 0ms)
+

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @contractkit/plugin-csharp

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marooned Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# @contractkit/plugin-csharp
+
+Generates a C#/.NET SDK client from ContractKit `.ck` files.
+
+The output is built on `System.Text.Json` and `HttpClient` from the shared framework and takes **no
+NuGet dependencies at all**, so a generated SDK restores and builds with no feed reachable.
+
+## Install
+
+```bash
+pnpm add -D @contractkit/plugin-csharp
+```
+
+## Configure
+
+```json
+{
+    "plugins": {
+        "@contractkit/plugin-csharp": {
+            "baseDir": "clients/csharp/",
+            "namespace": "Acme.Sdk",
+            "sdkName": "AcmeSdk",
+            "scaffold": true
+        }
+    }
+}
+```
+
+| Option            | Default           | Meaning                                                                 |
+| ----------------- | ----------------- | ----------------------------------------------------------------------- |
+| `baseDir`         | `csharp-sdk`      | Output directory, relative to the config's `rootDir`.                   |
+| `namespace`       | `ContractKit.Sdk` | Root namespace for the generated sources.                               |
+| `sdkName`         | `Sdk`             | Aggregator class name, and the assembly name when scaffolding.          |
+| `includeInternal` | `false`           | Emit client methods for operations marked `internal`.                   |
+| `scaffold`        | `false`           | Write `<SdkName>.csproj` once, as a user-owned file. Never overwritten. |
+
+Config arrives as JSON, so it is validated at run time: an invalid namespace, a namespace segment
+that is a C# keyword, or a non-boolean flag fails the build rather than emitting C# that cannot
+compile.
+
+## What it emits
+
+```
+<baseDir>/
+    Runtime/SdkRuntime.cs     SdkHttp, SdkOptions, SdkException, SdkResponse, SdkPart
+    Runtime/Converters.cs     SdkJson.Options and the scalar converters
+    Models/<File>.cs          one file per contract file
+    Clients/<File>Client.cs   one client per operations file
+    <SdkName>.cs              the aggregator
+    <SdkName>.csproj          only with `scaffold: true`, written once
+```
+
+Generated sources are rewritten every run. The project file is not: it is emitted `ifAbsent`, so it
+is created once and then belongs to you.
+
+Every generated file opens with `// <auto-generated/>` and `#nullable enable`, and carries its own
+`using` block, so the output does not depend on the project's implicit usings.
+
+## Using the client
+
+```csharp
+using Acme.Sdk;
+using Acme.Sdk.Runtime;
+
+using var sdk = new AcmeSdk(new SdkOptions
+{
+    BaseUrl = "https://api.example.com",
+    Headers = _ => ValueTask.FromResult<IReadOnlyDictionary<string, string>>(
+        new Dictionary<string, string> { ["authorization"] = $"Bearer {token}" }),
+});
+
+var payment = await sdk.Billing.GetPaymentAsync(paymentId);
+```
+
+`Headers` is called once per request, so a token can be refreshed without rebuilding the SDK. Pass
+your own `HttpClient` through `SdkOptions.HttpClient` to control handlers or retries; the SDK then
+never disposes it.
+
+A status outside 2xx that the contract does not declare throws `SdkException`, which derives from
+`HttpRequestException` and carries the status, the raw body, and the body parsed as JSON.
+
+Serialize a generated model by hand with `SdkJson.Options`: `decimal`, `bigint` and `duration` need
+the converters registered there.
+
+## Type mapping
+
+| `.ck`                                | C#                      | `.ck`                       | C#               |
+| ------------------------------------ | ----------------------- | --------------------------- | ---------------- |
+| `string`, `email`, `url`, `interval` | `string`                | `date`                      | `DateOnly`       |
+| `number`                             | `double`                | `time`                      | `TimeOnly`       |
+| `int`                                | `long`                  | `datetime`                  | `DateTimeOffset` |
+| `bigint`                             | `BigInteger`            | `duration`                  | `TimeSpan`       |
+| `decimal`                            | `decimal`               | `uuid`                      | `Guid`           |
+| `boolean`                            | `bool`                  | `binary`                    | `byte[]`         |
+| `array(T)`                           | `List<T>`               | `null`                      | `object?`        |
+| `record(string, V)`                  | `Dictionary<string, V>` | `unknown`, `json`, `object` | `JsonElement`    |
+
+`int` is a JavaScript safe integer in the source language, which overflows a 32-bit `int`, so it
+maps to `long`. `decimal` travels as a quoted JSON string and refuses to read an unquoted number,
+matching the server's own schema. `duration` travels as ISO 8601 rather than the framework's
+`d.hh:mm:ss` default. Both, and `bigint`, need the converters in `SdkJson.Options`.
+
+## Optional and nullable
+
+Each property says for itself whether a null is written, so the two are not conflated:
+
+| Contract       | C#                                                         | On the wire       |
+| -------------- | ---------------------------------------------------------- | ----------------- |
+| `x: T`         | `public required T X { get; init; }`                       | always written    |
+| `x?: T`        | `[JsonIgnore(WhenWritingNull)] public T? X { get; init; }` | omitted when null |
+| `x: T \| null` | `public required T? X { get; init; }`                      | `null` is written |
+| `x: T = v`     | `public T X { get; init; } = v;`                           | always written    |
+
+A missing required property is a read error rather than a silent default. Every property is either
+`required` or initialized, so the generated SDK compiles with warnings as errors.
+
+## Inheritance, and read versus Input variants
+
+Bases are flattened into each record, applying the same later-wins override rule the inheritance
+validator enforces. A contract with a `readonly` or `writeonly` field, or one reached by such a
+contract, is emitted twice: `<Name>` for what a response carries and `<Name>Input` for what a
+request sends. `format(input=)` and `format(output=)` rename the wire keys of each direction; a
+model that is not split can only carry one key set, and asking for two is reported as a warning.
+
+## Unions and anonymous shapes
+
+The `.ck` language lets a union, an enum, an object literal or a tuple appear anonymously inside a
+field. C# needs a name for each, so a project-wide pass assigns one, named after the model and field
+that hold it.
+
+- A **plain union** becomes an abstract record closed by a private constructor, with one nested
+  member record each. Reading tries members in declaration order, which is what the server's own
+  schema does.
+- A **discriminated union** becomes an interface its member records implement, with a converter that
+  dispatches on the tag. An interface rather than an abstract base, so one contract can belong to
+  several unions; the tag stays a real property rather than serializer metadata.
+- A **tuple** becomes a record with a converter that reads and writes a JSON array, so it travels
+  correctly even nested inside a `List<>`.
+- An **inline object** becomes a record, and an **inline enum** a C# enum.
+
+## Response shapes
+
+A method returns the response body directly. Three things change that:
+
+- A status declaring **response headers** returns `<Method>Result(Data, Headers)`, or
+  `<Method>Headers` when there is no body.
+- An operation the client can observe at **several statuses** returns an abstract
+  `<Method>Response` with a `Status<code>` leaf each.
+- A status declaring **several content types** returns one leaf per mime.
+
+A status outside 2xx that the contract declares as an outcome is passed as an expected status and
+comes back as a value; everything else throws `SdkException`, and the method documents which.
+
+## Scaffolding
+
+`scaffold: true` writes `<SdkName>.csproj` once, targeting `net10.0` with nullable enabled and no
+package reference. It is emitted `ifAbsent`, so it is created once and never regenerated: add a
+package id, a version or an analyzer set and the next build leaves them alone.
+
+## Status and known limitations
+
+1. **Clients are not grouped by area.** One client per `.ck` file, as in the Python and Kotlin
+   SDKs. `keys.area` and `keys.subarea` are ignored.
+2. **A `binary` field inside a JSON body is base64.** No two ContractKit SDKs agree on this, so it
+   interoperates only with a service that agrees. Binary really travels as an
+   `application/octet-stream` body or a multipart part, both of which are exact.
+3. **`decimal` is the BCL's 28-digit type.** A contract decimal wider than that fails to read.
+4. **`DateTimeOffset` writes `+00:00`, not `Z`.** The generated server accepts both.
+5. **The three scalar converters are options-level.** Serialize a model yourself with
+   `SdkJson.Options`, or `decimal`, `bigint` and `duration` will not match the contract.
+6. **Only the first declared request mime is used**, since a method has one signature.
+7. **A type switch is not exhaustive.** C# has no compiler check that a union switch covers every
+   member, so each generated converter ends in a `default` that throws.

package/dist/codegen-client.d.ts

@@ -0,0 +1,35 @@
+import type { ModelNode, OpOperationNode, OpRootNode, OpRouteNode, ParamSource } from '@contractkit/core';
+import type { HoistResult } from './hoist.js';
+export interface CSharpClientCodegenOptions {
+    namespace: string;
+    modelsWithInput: ReadonlySet<string>;
+    modelIndex?: ReadonlyMap<string, ModelNode>;
+    hoisted?: HoistResult;
+    includeInternal?: boolean;
+    warn?: (message: string) => void;
+}
+/** Whether the root has at least one operation eligible for client emission. */
+export declare function hasPublicOperations(root: OpRootNode, includeInternal?: boolean): boolean;
+export declare function deriveClientClassName(file: string): string;
+export declare function deriveClientPropertyName(file: string): string;
+/**
+ * Generate the client class for one operations file: one `Task`-returning method per public
+ * operation, plus the request and response shapes those methods name.
+ */
+export declare function generateCSharpClient(root: OpRootNode, opts: CSharpClientCodegenOptions): string;
+/**
+ * Render a route path as the `Path(...)` call that builds the URL.
+ *
+ * Literal segments stay string literals and dynamic ones go through `Segment(...)`, so exactly the
+ * values that came from the caller are percent-encoded. `params` says where a value lives: spread
+ * across the signature, or behind one `pathParams` argument when the route declares a model.
+ */
+export declare function buildPathExpression(path: string, params?: ParamSource): string;
+/**
+ * The SDK method name, in the same priority order every ContractKit SDK uses: an explicit `sdk:`,
+ * then the operation's `name:`, then a name inferred from the verb and path. C# spells it
+ * PascalCase with an `Async` suffix, which is what a .NET caller expects of a `Task`-returning
+ * method.
+ */
+export declare function deriveMethodName(op: OpOperationNode, route: OpRouteNode): string;
+//# sourceMappingURL=codegen-client.d.ts.map

package/dist/codegen-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-client.d.ts","sourceRoot":"","sources":["../src/codegen-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,SAAS,EACT,eAAe,EAIf,UAAU,EACV,WAAW,EACX,WAAW,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAY9C,MAAM,WAAW,0BAA0B;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,UAAU,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5C,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAwBD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,UAAQ,GAAG,OAAO,CAOtF;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,0BAA0B,GAAG,MAAM,CA2E/F;AAwZD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAY9E;AAkFD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,CAIhF"}

package/dist/codegen-models.d.ts

@@ -0,0 +1,75 @@
+import type { ContractRootNode, ContractTypeNode, ModelNode, ScalarTypeNode } from '@contractkit/core';
+import type { HoistResult } from './hoist.js';
+export interface CSharpModelCodegenOptions {
+    /** Root namespace the SDK is generated into. Models land in `<namespace>.Models`. */
+    namespace: string;
+    /** Model names that have a distinct `Input` variant, including ones declared in other files. */
+    modelsWithInput?: ReadonlySet<string>;
+    /**
+     * Every model in the project, for flattening bases and intersections. Defaults to an index of
+     * this root's own models, which is enough for a single-file project and for unit tests.
+     */
+    modelIndex?: ReadonlyMap<string, ModelNode>;
+    /** Names assigned to anonymous types by {@link collectHoistedTypes}, across the whole project. */
+    hoisted?: HoistResult;
+    warn?: (message: string) => void;
+}
+/**
+ * Generate the C# models file for one contract root: a `sealed record` per model, plus `<Name>Input`
+ * variants, enums, aliases, and the records, interfaces and converters standing in for the unions
+ * and anonymous shapes this file owns.
+ *
+ * Every model in the project shares the single `<namespace>.Models` namespace, so a reference to a
+ * model declared in another `.ck` file needs no import and resolves by name alone. That is also what
+ * lets an interface declared in one file be implemented by a record generated in another.
+ */
+export declare function generateCSharpModels(root: ContractRootNode, opts: CSharpModelCodegenOptions): string;
+/**
+ * The complete set of model names that need a distinct `Input` variant: the ones passed in, plus
+ * the transitive closure over `models`.
+ *
+ * The hoisting pass and the renderer both have to agree on this — a hoisted shape whose Input twin
+ * one of them thinks is unnecessary would leave the other referring to a type nobody emitted.
+ */
+export declare function resolveModelsWithInput(models: readonly ModelNode[], external?: ReadonlySet<string>): Set<string>;
+interface RenderContext {
+    namespace: string;
+    modelsWithInput: ReadonlySet<string>;
+    modelIndex: ReadonlyMap<string, ModelNode>;
+    hoisted?: HoistResult;
+    /** `global using` alias lines this file has to emit above its own `using` block. */
+    globalAliases: string[];
+    /** When set, type names render fully qualified, as a `global using` alias target must be. */
+    qualify?: boolean;
+    warn?: (message: string) => void;
+}
+/** Build a rendering context for a file outside the models namespace, such as a client. */
+export declare function createRenderContext(opts: CSharpModelCodegenOptions & {
+    modelsWithInput: ReadonlySet<string>;
+}): RenderContext;
+/**
+ * Assemble a generated C# file: header, nullable context, global aliases, usings, namespace, bodies.
+ *
+ * `// <auto-generated/>` turns the nullable context off, so `#nullable enable` follows it
+ * explicitly. A `global using` alias has to precede every ordinary `using` in its file, which is
+ * why the aliases are collected during rendering and emitted here rather than inline.
+ */
+export declare function renderFile(namespaceName: string, globalAliases: readonly string[], usings: readonly string[], bodies: string[]): string;
+/**
+ * Render a ContractKit type as its C# type expression. Never returns a nullable type unless the type
+ * itself is one — the caller appends `?` from the field's own `optional`/`nullable` flags.
+ *
+ * @param forInput - When true, a reference to a model or hoisted shape with an Input variant renders
+ *   as `<Name>Input`.
+ * @throws {Error} Via the scalar renderer, if a scalar has no C# mapping.
+ */
+export declare function renderCSharpType(type: ContractTypeNode, ctx: RenderContext, forInput?: boolean): string;
+/**
+ * Map a ContractKit scalar to its C# type.
+ *
+ * @throws {Error} When a scalar has no mapping, so a scalar added to core fails the build here
+ *   rather than emitting C# that does not compile.
+ */
+export declare function renderScalar(name: ScalarTypeNode['name'], ctx: RenderContext): string;
+export type { RenderContext };
+//# sourceMappingURL=codegen-models.d.ts.map

package/dist/codegen-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-models.d.ts","sourceRoot":"","sources":["../src/codegen-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAa,SAAS,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAElH,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,yBAAyB;IACtC,qFAAqF;IACrF,SAAS,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,UAAU,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5C,kGAAkG;IAClG,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,yBAAyB,GAAG,MAAM,CAwBpG;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CAG3H;AAID,UAAU,aAAa;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,oFAAoF;IACpF,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,yBAAyB,GAAG;IAAE,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,GAAG,aAAa,CAS7H;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAYvI;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,UAAQ,GAAG,MAAM,CAqDrG;AAqBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CA2CrF;AAooBD,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/codegen-sdk.d.ts

@@ -0,0 +1,13 @@
+export interface SdkAggregatorClient {
+    className: string;
+    propertyName: string;
+}
+/**
+ * Generate the SDK entry point: one property per generated client, all sharing a single
+ * [SdkHttp] and therefore a single `HttpClient`.
+ *
+ * The Python SDK gives each sub-client its own connection pool; that is a bug worth not repeating,
+ * since a caller holding one SDK expects one set of connections.
+ */
+export declare function generateSdkCs(namespaceName: string, sdkName: string, clients: readonly SdkAggregatorClient[]): string;
+//# sourceMappingURL=codegen-sdk.d.ts.map

package/dist/codegen-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-sdk.d.ts","sourceRoot":"","sources":["../src/codegen-sdk.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,CAqCrH"}

package/dist/hoist.d.ts

@@ -0,0 +1,53 @@
+import type { ContractRootNode, ContractTypeNode, FieldNode, ModelNode } from '@contractkit/core';
+/**
+ * C# needs a name for every shape a caller can hold. The `.ck` language does not: a union, an enum,
+ * or an object literal can appear anonymously inside a field. This pass walks every model in the
+ * project and assigns each such node a stable C# declaration, so the type renderer can emit a name
+ * and the file emitter can emit the declaration behind it.
+ *
+ * It runs once over all contract roots rather than per file, because a discriminated union declared
+ * in one file makes its member records, which may live in any other file, implement its interface.
+ */
+export type HoistKind = 'enum' | 'record' | 'plainUnion' | 'discriminatedUnion' | 'tuple';
+export interface HoistedMember {
+    /** The C# type of the member: a model name, or a hoisted declaration's name. */
+    typeName: string;
+    /** Nested record name inside a plain union's abstract record (`OfPayment`). */
+    wrapperName?: string;
+    /** Discriminator value for a discriminated union member. */
+    tag?: string;
+    type: ContractTypeNode;
+}
+export interface HoistedDecl {
+    kind: HoistKind;
+    name: string;
+    /** The `.ck` file whose models file carries this declaration. */
+    ownerFile: string;
+    /** Whether a distinct `<Name>Input` twin has to be emitted alongside it. */
+    needsInput: boolean;
+    /** Rendered references become `Name?` — the union had a `null` member. */
+    nullable?: boolean;
+    members?: HoistedMember[];
+    discriminator?: string;
+    fields?: FieldNode[];
+    values?: string[];
+    items?: ContractTypeNode[];
+    description?: string;
+}
+export interface HoistResult {
+    /** The declaration standing in for an anonymous node, keyed by AST node identity. */
+    byNode: Map<ContractTypeNode, HoistedDecl>;
+    byName: Map<string, HoistedDecl>;
+    /** Declarations each `.ck` file's models file has to emit, in collection order. */
+    byFile: Map<string, HoistedDecl[]>;
+    /** Model record name → the union interfaces it must declare it implements. */
+    memberships: Map<string, string[]>;
+}
+export interface HoistOptions {
+    modelIndex: ReadonlyMap<string, ModelNode>;
+    modelsWithInput: ReadonlySet<string>;
+    warn?: (message: string, file: string) => void;
+}
+/** Analyse every model in the project and name the anonymous types that need a C# declaration. */
+export declare function collectHoistedTypes(roots: readonly ContractRootNode[], opts: HoistOptions): HoistResult;
+//# sourceMappingURL=hoist.d.ts.map

package/dist/hoist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hoist.d.ts","sourceRoot":"","sources":["../src/hoist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAIlG;;;;;;;;GAQG;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,oBAAoB,GAAG,OAAO,CAAC;AAE1F,MAAM,WAAW,aAAa;IAC1B,gFAAgF;IAChF,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,gBAAgB,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,UAAU,EAAE,OAAO,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IACxB,qFAAqF;IACrF,MAAM,EAAE,GAAG,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;IAC3C,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACjC,mFAAmF;IACnF,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IACnC,8EAA8E;IAC9E,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,YAAY;IACzB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,kGAAkG;AAClG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,WAAW,CAwBvG"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import type { ContractKitPlugin } from '@contractkit/core';
+export interface CSharpSdkPluginConfig {
+    /** Output directory relative to rootDir (default: "csharp-sdk") */
+    baseDir?: string;
+    /** Root namespace for the generated sources, e.g. "Acme.Sdk" (default: "ContractKit.Sdk") */
+    namespace?: string;
+    /** Aggregator class name (default: "Sdk"). Also the assembly name when scaffolding. */
+    sdkName?: string;
+    /**
+     * Whether to emit client methods for operations marked `internal`. Defaults to `false` —
+     * internal ops are omitted so consumers don't pick them up.
+     */
+    includeInternal?: boolean;
+    /** Emit `<SdkName>.csproj` once, as a user-owned file. Never overwritten. */
+    scaffold?: boolean;
+}
+/**
+ * Bumped when the C# codegen output shape changes in a way that should invalidate every per-file
+ * fingerprint, so a plugin upgrade forces full regeneration even when no `.ck` file has changed.
+ */
+export declare const CSHARP_CODEGEN_VERSION = "1";
+declare const plugin: ContractKitPlugin;
+export default plugin;
+export declare function createCSharpSdkPlugin(config: CSharpSdkPluginConfig, rootDir: string): ContractKitPlugin;
+/**
+ * Reject config that would generate C# which cannot compile. These are runtime checks, not just
+ * types: config arrives as JSON, so the TypeScript interface constrains programmatic callers only.
+ */
+export declare function assertValidConfig(config: CSharpSdkPluginConfig): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,iBAAiB,EAUpB,MAAM,mBAAmB,CAAC;AAoB3B,MAAM,WAAW,qBAAqB;IAClC,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6FAA6F;IAC7F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAO1C,QAAA,MAAM,MAAM,EAAE,iBAMb,CAAC;AAEF,eAAe,MAAM,CAAC;AAEtB,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAOvG;AAKD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,CA2BrE"}