more c1 updates

Author: smrz2001

docs/protocol/ceramic-one/concepts.mdx

@@ -91,10 +91,10 @@ Consumers can either handle the event `data` payloads directly using their own b
 or they can leverage Ceramic's standard data pipeline to combine messages into new forms, including
 mutable data structures and other key components of a modern data environment.
 
-## Archival Storage on Recall
+## Archival Storage on S3
 
-The Ceramic Network in the context of Recall is a communication, synchronization, and validation for
-ephemeral events. While this architecture is intentionally flexible to allow for bespoke molding of
+The Ceramic Network is a communication, synchronization, and validation for persistent or ephemeral
+events. While this architecture is intentionally flexible to allow for bespoke molding of
 custom data pipelines, schema, and other logic, it requires a data availability layer to provide
 archival assurances and programmatic access.
 
@@ -103,7 +103,7 @@ transformations across the Ceramic data pipeline, giving developers access to ra
 document states, or custom document states based on bespoke logic developers implement into their
 pipelines.
 
-These parquet files containing Ceramic events are stored in Recall buckets. The columnar storage
+These parquet files containing Ceramic events are stored in S3 buckets. The columnar storage
 format of parquet files is highly efficient for analytical queries, therefore reducing data transfer
 and storage costs. Parquet also supports performant compression schemes which reduces file sizes
 further without compromising performance.

docs/protocol/ceramic-one/usage/consume.mdx

@@ -11,7 +11,7 @@ assumes that you've already followed our
 
 :::
 
-Let's explore how use Ceramic to read messages from a stream. Ceramic nodes in the Recall network
+Let's explore how use Ceramic to read messages from a stream. Nodes in the Ceramic Network 
 subscribe to data by expressing an [interest](/docs/protocol/ceramic-one/concepts#interests) in a
 given data model. This interest is broadcast to the node's peers in the network, who will then
 initiate periodic synchronization of all data conforming to that model via [Recon](#), a protocol
@@ -29,11 +29,15 @@ This method allows end users to register interest in a specific data model withi
 network. The model's identifier is, itself, the ID of a stream that defines its schema.
 
 ```typescript
-// My moddel stream ID
+import { CeramicClient, EventsFeedParams } from "@ceramic-sdk/http-client";
+
+const ceramic = new CeramicClient({ url: "http://localhost:5101" });
+
+// My model stream ID
 const modelId = "kjzl6hvfrbw6c5i55ks5m4hhyuh0jylw4g7x0asndu97i7luts4dfzvm35oev65";
 
 // Listen to all events written to instances of this modela
-await ceramic.registerInterestModel(model);
+await ceramic.registerInterestModel(modelId);
 ```
 
 Upon success, the function won't return anything, but it will throw if there's an issue. You're now
@@ -53,9 +57,9 @@ but we'll define them to illustrate their purpose. If no limit is defined, the S
 new events from the resume token.
 
 ```typescript
-const params: EventFeedParams = {
+const params: EventsFeedParams = {
   limit: 50,
-  resumeAt: "myResumeToken", // The resumeToken returned from the last call to `getEventsFeed`
+  resumeAt: "0", // The resumeToken returned from the last call to `getEventsFeed`
 };
 ```
 
@@ -92,10 +96,11 @@ type Event = {
 };
 ```
 
-To fetch an event by it's id, we use `getEvent`
+To fetch an event by its id, we use `getEvent`:
 
 ```typescript
-const event = await ceramic.getEvent(myEventId);
+const eventId = events.events[0].id; // The ID of the event we want to fetch
+const event = await ceramic.getEvent(eventId);
 ```
 
 There are also a small collection of simple helper functions to extract specific parts of an event.
@@ -105,32 +110,41 @@ There are also a small collection of simple helper functions to extract specific
 Extract the data payload from an event.
 
 ```typescript
-const data = await ceramic.getEventData(myEventId);
+const data = await ceramic.getEventData(eventId);
 ```
 
-This is equivalent to
+This is equivalent to:
 
 ```typescript
-ceramic.getEvent(myEventId).then((event) => event.data);
+ceramic.getEvent(eventId).then((event) => event.data);
 ```
 
 #### `getEventCAR`
 
 Extract the data payload from an event and parse it as a CAR file.
 
 ```typescript
-const data = await ceramic.getEventCAR(myEventId);
+const data = await ceramic.getEventCAR(eventId);
 ```
 
 `data` will be the parsed payload of the event.
 
 #### `getEventType`
 
-This method is useful for cases where you know the schema of the payload. To use it, you must have a
-[codeco](https://github.com/ceramicnetwork/codeco) codec handy.
+This method is useful for cases where you know the schema of the payload. To use it, you must have the
+[codeco](https://github.com/ceramicnetwork/codeco) package and your codec handy.
+
+```bash
+npm install --save codeco
+```
+
+Then, you can use it like this:
 
 ```typescript
+import { Decoder } from "codeco";
+
 type MyPayload = /* ... */;
 const decoder: Decoder<unknown, MyPayload> = /* ... */;
-const data: MyPayload = await ceramic.getEventType(decoder, myEventId);
+
+const data: MyPayload = await ceramic.getEventType(decoder, eventId);
 ```

docs/protocol/ceramic-one/usage/installation.mdx

@@ -12,7 +12,7 @@ The SDK is written in TypeScript and published to NPM as `@ceramic-sdk`, with a
 sub-packages:
 
 - `@ceramic-sdk/events`: Utilities for creating and signing events that comply to the
-  [Recall Event Store standards.](https://developers.ceramic.network/docs/protocol/js-ceramic/streams/event-log)
+  [Ceramic Event Log specifications](https://developers.ceramic.network/docs/protocol/js-ceramic/streams/event-log)
 - `@ceramic-sdk/http-client`: A simple client for
   [ceramic-one's](https://github.com/ceramicnetwork/rust-ceramic) HTTP APIs.
 - `@ceramic-sdk/identifiers`: A handful of useful types for identifying streams and events.

docs/protocol/ceramic-one/usage/query.mdx

@@ -45,16 +45,16 @@ queried and transmitted efficiently, ideal for intense data workloads.
 
 The `@ceramic-sdk/flight-sql-client` is a package designed to run server-side only. Using this
 client needs a [ceramic-one](https://github.com/ceramicnetwork/rust-ceramic) daemon running with
-experimental flags which point to your Recall-S3 adapter:
+experimental flags which point to your S3 bucket:
 
 ```bash
-ceramic-one -- daemon --experimental-features --flight-sql-bind-address 0.0.0.0:5102 --s3-bucket your-recall-account.your-bucket-name
+ceramic-one -- daemon --experimental-features --flight-sql-bind-address 0.0.0.0:5102 --object-store-url s3://your-bucket-name
 ```
 
 ### Install the flight-sql package
 
 ```bash
-npm install --save @ceramic-sdk/flight-sql-client
+npm install --save @ceramic-sdk/flight-sql-client apache-arrow
 ```
 
 ### Create a client instance
@@ -79,7 +79,7 @@ const client = await createFlightSqlClient(OPTIONS);
 ### Execute a query
 
 ```typescript
-const buffer = await client.preparedStatement(
+const buffer = await client.preparedQuery(
   "SELECT * from conclusion_events where stream_type = $1",
   new Array(["$1", "3"])
 );