The generated package

src/generated/
├── src/
│   ├── types.ts        your Go types, as TypeScript
│   ├── ops.ts          the operation manifest: cache contract per endpoint
│   ├── hooks.ts        one typed binding per operation
│   ├── rest.ts         typed method per REST endpoint
│   ├── codecs.ts       wire-name to client-name mapping
│   ├── client.ts       base client: auth, request assembly
│   ├── fetch.ts        HTTP transport
│   ├── errors.ts       typed error classes
│   ├── pagination.ts   pagination helpers
│   └── index.ts        re-exports everything above
├── tests/
├── package.json
├── tsconfig.json
└── README.md

export interface Customer {
  id: string;
  name: string;
}

export interface Order {
  customer: Customer;
  id: string;
  status: string;
  total: number;
}

export interface OrderPage {
  items: Order[];
  total: number;
}

export const ops = {
  listOrders: {
    method: 'GET',
    path: '/orders',
    entity: 'Order',
    rootType: 'OrderPage',
    provides: ['Order:{id}', 'Order[]'],
    invalidates: [],
    responseCodec: 'OrderPage',
  },
  createOrder: {
    method: 'POST',
    path: '/orders',
    entity: 'Order',
    rootType: 'Order',
    provides: ['Order:{id}'],
    invalidates: ['Order[]'],
    responseCodec: 'Order',
  },
} as const satisfies Record<string, OperationMeta>;

export const entities = {
  Customer: { idField: 'id' },
  Order: { idField: 'id', fields: { customer: 'Customer' } },
  OrderPage: { fields: { items: 'Order' } },
} as const satisfies Record<string, EntityMeta>;

export const streams = [
] as const;

/**
 * Typed hooks over the operation manifest.
 *
 * Generated. Each line is a binding, not an implementation.
 *
 * Requires @forge-go/client-core, which is not published yet -- it ships in a
 * later phase. "npm install" will fail on this package until it is; see the
 * generated README for details. The REST client in this same package does
 * not depend on it and works today.
 */

import { query, mutation } from '@forge-go/client-core';
import { ops } from './ops';

export const useGetCustomer = query(ops.getCustomer);
export const useListOrders = query(ops.listOrders);
export const useCreateOrder = mutation(ops.createOrder);
export const useGetOrder = query(ops.getOrder);
export const useUpdateOrder = mutation(ops.updateOrder);
export const useDeleteOrder = mutation(ops.deleteOrder);

export class RESTClient extends Client {
  public readonly listOrders = async (options?: { signal?: AbortSignal; retry?: { maxAttempts?: number } }): Promise<types.OrderPage> => {
    let __path = `/orders`;
    const config: RequestConfig = {
      method: 'GET',
      url: __path,
      signal: options?.signal,
      retry: options?.retry,
      responseCodec: "OrderPage",
    };

    return this.request<types.OrderPage>(config);
  };
}

// Generated codec table
//
// Describes, per schema, how a wire payload maps onto its TypeScript
// shape. `ts` is the client-side field name derived from the wire name by
// the configured FieldNaming strategy (or a FieldOverrides entry); encode
// and decode below walk this table to rename between the two.

export type Codec =
  | { kind: 'object'; fields: Record<string, { ts: string; codec?: string | undefined }>; required?: string[]; values?: string }
  | { kind: 'array'; items?: string }
  | { kind: 'record'; values?: string }
  | { kind: 'union'; discriminator?: { wire: string; map: Record<string, string> }; members: string[] }
  | { kind: 'passthrough' };

{
  "dependencies": {
    "@forge-go/client-core": ">=1",
    "eventsource": "^2.0.2",
    "ws": "^8.16.0"
  }
}