@interfere/attio 0.1.2

package/src/sdk/tasks.ts

@@ -0,0 +1,111 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { tasksCreate } from "../funcs/tasks-create.js";
+import { tasksDelete } from "../funcs/tasks-delete.js";
+import { tasksGet } from "../funcs/tasks-get.js";
+import { tasksList } from "../funcs/tasks-list.js";
+import { tasksUpdate } from "../funcs/tasks-update.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Tasks extends ClientSDK {
+  /**
+   * List tasks
+   *
+   * @remarks
+   * List all tasks. Results are sorted by creation date, from oldest to newest.
+   *
+   * Required scopes: `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+   */
+  async list(
+    request?: operations.GetV2TasksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2TasksResponse> {
+    return unwrapAsync(tasksList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a task
+   *
+   * @remarks
+   * Creates a new task.
+   *
+   * At present, tasks can only be created from plaintext without record reference formatting.
+   *
+   * Required scopes: `task:read-write`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+   */
+  async create(
+    request: operations.PostV2TasksRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostV2TasksResponse> {
+    return unwrapAsync(tasksCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a task
+   *
+   * @remarks
+   * Get a single task by ID.
+   *
+   * Required scopes: `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+   */
+  async get(
+    request: operations.GetV2TasksTaskIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2TasksTaskIdResponse> {
+    return unwrapAsync(tasksGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a task
+   *
+   * @remarks
+   * Updates an existing task by `task_id`. At present, only the `deadline_at`, `is_completed`, `linked_records`, and `assignees` fields can be updated.
+   *
+   * Required scopes: `task:read-write`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+   */
+  async update(
+    request: operations.PatchV2TasksTaskIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchV2TasksTaskIdResponse> {
+    return unwrapAsync(tasksUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a task
+   *
+   * @remarks
+   * Delete a task by ID.
+   *
+   * Required scopes: `task:read-write`.
+   */
+  async delete(
+    request: operations.DeleteV2TasksTaskIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteV2TasksTaskIdResponse> {
+    return unwrapAsync(tasksDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/threads.ts

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { threadsGet } from "../funcs/threads-get.js";
+import { threadsList } from "../funcs/threads-list.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Threads extends ClientSDK {
+  /**
+   * List threads
+   *
+   * @remarks
+   * List threads of comments on a record or list entry.
+   *
+   * To view threads on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+   *
+   * To view threads on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+   *
+   * Required scopes: `comment:read`.
+   */
+  async list(
+    request?: operations.GetV2ThreadsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2ThreadsResponse> {
+    return unwrapAsync(threadsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a thread
+   *
+   * @remarks
+   * Get all comments in a thread.
+   *
+   * To view threads on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+   *
+   * To view threads on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+   *
+   * Required scopes: `comment:read`.
+   */
+  async get(
+    request: operations.GetV2ThreadsThreadIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2ThreadsThreadIdResponse> {
+    return unwrapAsync(threadsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/transcripts.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { transcriptsGet } from "../funcs/transcripts-get.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Transcripts extends ClientSDK {
+  /**
+   * Get call transcript
+   *
+   * @remarks
+   * Get the transcript for a call recording.
+   *
+   * This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+   *
+   * Required scopes: `meeting:read`, `call_recording:read`.
+   */
+  async get(
+    request:
+      operations.GetV2MeetingsMeetingIdCallRecordingsCallRecordingIdTranscriptRequest,
+    options?: RequestOptions,
+  ): Promise<
+    operations.GetV2MeetingsMeetingIdCallRecordingsCallRecordingIdTranscriptResponse
+  > {
+    return unwrapAsync(transcriptsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/webhooks.ts

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { webhooksCreate } from "../funcs/webhooks-create.js";
+import { webhooksDelete } from "../funcs/webhooks-delete.js";
+import { webhooksGet } from "../funcs/webhooks-get.js";
+import { webhooksList } from "../funcs/webhooks-list.js";
+import { webhooksUpdate } from "../funcs/webhooks-update.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Webhooks extends ClientSDK {
+  /**
+   * List webhooks
+   *
+   * @remarks
+   * Get all of the webhooks in your workspace.
+   *
+   * Required scopes: `webhook:read`.
+   */
+  async list(
+    request?: operations.GetV2WebhooksRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2WebhooksResponse> {
+    return unwrapAsync(webhooksList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a webhook
+   *
+   * @remarks
+   * Create a webhook and associated subscriptions.
+   *
+   * Required scopes: `webhook:read-write`.
+   */
+  async create(
+    request: operations.PostV2WebhooksRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostV2WebhooksResponse> {
+    return unwrapAsync(webhooksCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a webhook
+   *
+   * @remarks
+   * Get a single webhook.
+   *
+   * Required scopes: `webhook:read`.
+   */
+  async get(
+    request: operations.GetV2WebhooksWebhookIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2WebhooksWebhookIdResponse> {
+    return unwrapAsync(webhooksGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a webhook
+   *
+   * @remarks
+   * Update a webhook and associated subscriptions.
+   *
+   * Required scopes: `webhook:read-write`.
+   */
+  async update(
+    request: operations.PatchV2WebhooksWebhookIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchV2WebhooksWebhookIdResponse> {
+    return unwrapAsync(webhooksUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a webhook
+   *
+   * @remarks
+   * Delete a webhook by ID.
+   *
+   * Required scopes: `webhook:read-write`.
+   */
+  async delete(
+    request: operations.DeleteV2WebhooksWebhookIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteV2WebhooksWebhookIdResponse> {
+    return unwrapAsync(webhooksDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/workspace-members.ts

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { workspaceMembersGet } from "../funcs/workspace-members-get.js";
+import { workspaceMembersList } from "../funcs/workspace-members-list.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class WorkspaceMembers extends ClientSDK {
+  /**
+   * List workspace members
+   *
+   * @remarks
+   * Lists all workspace members in the workspace.
+   *
+   * Required scopes: `user_management:read`.
+   */
+  async list(
+    options?: RequestOptions,
+  ): Promise<operations.GetV2WorkspaceMembersResponse> {
+    return unwrapAsync(workspaceMembersList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Get a workspace member
+   *
+   * @remarks
+   * Gets a single workspace member by ID.
+   *
+   * Required scopes: `user_management:read`.
+   */
+  async get(
+    request: operations.GetV2WorkspaceMembersWorkspaceMemberIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetV2WorkspaceMembersWorkspaceMemberIdResponse> {
+    return unwrapAsync(workspaceMembersGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export const blobLikeSchema: z.ZodMiniType<Blob, Blob> = z.custom<Blob>(
+  isBlobLike,
+  {
+    message: "expected a Blob, File or Blob-like object",
+    abort: true,
+  },
+);
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/types/const-date-time.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export function constDateTime(
+  val: string,
+): z.ZodMiniType<string, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivalent to ${val}`);
+}

package/src/types/default-to-zero-value.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { type Unrecognized, unrecognized } from "./unrecognized.js";
+
+let globalCount = 0;
+let refCount = 0;
+
+export function defaultToZeroValue<T>(value: T): Unrecognized<T> {
+  globalCount++;
+  return unrecognized(value);
+}
+
+export function startCountingDefaultToZeroValue() {
+  refCount++;
+  const start = globalCount;
+  return {
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number) => {
+      const count = globalCount - start;
+      // Reset globalCount back to start, then add only the specified delta
+      globalCount = start + (delta ?? count);
+      if (--refCount === 0) globalCount = 0;
+      return count;
+    },
+  };
+}

package/src/types/discriminated-union.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+const UNKNOWN = Symbol("UNKNOWN");
+
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> =
+  & {
+    [K in Discriminator]: UnknownValue;
+  }
+  & {
+    raw: unknown;
+    isUnknown: true;
+  };
+
+export function isUnknown<Discriminator extends string>(
+  value: unknown,
+): value is Unknown<Discriminator> {
+  return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion<
+  InputDiscriminator extends string,
+  TOptions extends Readonly<Record<string, z.ZodMiniType>>,
+  UnknownValue extends string = "UNKNOWN",
+  OutputDiscriminator extends string = InputDiscriminator,
+>(
+  inputPropertyName: InputDiscriminator,
+  options: TOptions,
+  opts: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+  } = {},
+): z.ZodMiniType<
+  | z.output<TOptions[keyof TOptions]>
+  | Unknown<OutputDiscriminator, UnknownValue>,
+  unknown
+> {
+  const { unknownValue = "UNKNOWN" as UnknownValue, outputPropertyName } = opts;
+  return z.pipe(
+    z.unknown(),
+    z.transform((input) => {
+      const fallback = Object.defineProperties(
+        {
+          raw: input,
+          [outputPropertyName ?? inputPropertyName]: unknownValue,
+          isUnknown: true as const,
+        },
+        { [UNKNOWN]: { value: true, enumerable: false, configurable: false } },
+      );
+
+      const isObject = typeof input === "object" && input !== null;
+      if (!isObject) return fallback;
+
+      const discriminator = input[inputPropertyName as keyof typeof input];
+      if (typeof discriminator !== "string") return fallback;
+      if (!(discriminator in options)) return fallback;
+
+      const schema = options[discriminator];
+      if (!schema) return fallback;
+
+      // Start counters before parsing to track nested unrecognized/zeroDefault values
+      const unrecognizedCtr = startCountingUnrecognized();
+      const zeroDefaultCtr = startCountingDefaultToZeroValue();
+
+      const result = z.safeParse(schema, input);
+      if (!result.success) {
+        // Parse failed - don't propagate any counts from the failed attempt
+        unrecognizedCtr.end(0);
+        zeroDefaultCtr.end(0);
+        return fallback;
+      }
+
+      // Parse succeeded - propagate the actual counts
+      unrecognizedCtr.end();
+      zeroDefaultCtr.end();
+
+      if (outputPropertyName) {
+        (result.data as any)[outputPropertyName] = discriminator;
+      }
+
+      return result.data;
+    }),
+  ) as any;
+}

package/src/types/enums.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { Unrecognized, unrecognized } from "./unrecognized.js";
+
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.string(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodMiniType<OpenEnum<T>, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.pipe(z.int(), z.transform(x => unrecognized(x))),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodMiniType<string, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodMiniType<number, OpenEnum<T>> {
+  return z.int() as any;
+}