@pipe2-ai/sdk 0.1.0

package/dist/generated/sdk.d.ts

@@ -0,0 +1,2619 @@
+import { DocumentNode } from 'graphql';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    bpchar: {
+        input: any;
+        output: any;
+    };
+    jsonb: {
+        input: any;
+        output: any;
+    };
+    timestamp: {
+        input: any;
+        output: any;
+    };
+    timestamptz: {
+        input: any;
+        output: any;
+    };
+    uuid: {
+        input: any;
+        output: any;
+    };
+};
+/** Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'. */
+export type Boolean_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['Boolean']['input']>;
+    _gt?: InputMaybe<Scalars['Boolean']['input']>;
+    _gte?: InputMaybe<Scalars['Boolean']['input']>;
+    _in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['Boolean']['input']>;
+    _lte?: InputMaybe<Scalars['Boolean']['input']>;
+    _neq?: InputMaybe<Scalars['Boolean']['input']>;
+    _nin?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+};
+/** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */
+export type Int_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['Int']['input']>;
+    _gt?: InputMaybe<Scalars['Int']['input']>;
+    _gte?: InputMaybe<Scalars['Int']['input']>;
+    _in?: InputMaybe<Array<Scalars['Int']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['Int']['input']>;
+    _lte?: InputMaybe<Scalars['Int']['input']>;
+    _neq?: InputMaybe<Scalars['Int']['input']>;
+    _nin?: InputMaybe<Array<Scalars['Int']['input']>>;
+};
+/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
+export type String_Array_Comparison_Exp = {
+    /** is the array contained in the given array value */
+    _contained_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** does the array contain the given value */
+    _contains?: InputMaybe<Array<Scalars['String']['input']>>;
+    _eq?: InputMaybe<Array<Scalars['String']['input']>>;
+    _gt?: InputMaybe<Array<Scalars['String']['input']>>;
+    _gte?: InputMaybe<Array<Scalars['String']['input']>>;
+    _in?: InputMaybe<Array<Array<Scalars['String']['input']>>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Array<Scalars['String']['input']>>;
+    _lte?: InputMaybe<Array<Scalars['String']['input']>>;
+    _neq?: InputMaybe<Array<Scalars['String']['input']>>;
+    _nin?: InputMaybe<Array<Array<Scalars['String']['input']>>>;
+};
+/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
+export type String_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['String']['input']>;
+    _gt?: InputMaybe<Scalars['String']['input']>;
+    _gte?: InputMaybe<Scalars['String']['input']>;
+    /** does the column match the given case-insensitive pattern */
+    _ilike?: InputMaybe<Scalars['String']['input']>;
+    _in?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** does the column match the given POSIX regular expression, case insensitive */
+    _iregex?: InputMaybe<Scalars['String']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    /** does the column match the given pattern */
+    _like?: InputMaybe<Scalars['String']['input']>;
+    _lt?: InputMaybe<Scalars['String']['input']>;
+    _lte?: InputMaybe<Scalars['String']['input']>;
+    _neq?: InputMaybe<Scalars['String']['input']>;
+    /** does the column NOT match the given case-insensitive pattern */
+    _nilike?: InputMaybe<Scalars['String']['input']>;
+    _nin?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** does the column NOT match the given POSIX regular expression, case insensitive */
+    _niregex?: InputMaybe<Scalars['String']['input']>;
+    /** does the column NOT match the given pattern */
+    _nlike?: InputMaybe<Scalars['String']['input']>;
+    /** does the column NOT match the given POSIX regular expression, case sensitive */
+    _nregex?: InputMaybe<Scalars['String']['input']>;
+    /** does the column NOT match the given SQL regular expression */
+    _nsimilar?: InputMaybe<Scalars['String']['input']>;
+    /** does the column match the given POSIX regular expression, case sensitive */
+    _regex?: InputMaybe<Scalars['String']['input']>;
+    /** does the column match the given SQL regular expression */
+    _similar?: InputMaybe<Scalars['String']['input']>;
+};
+export type Add_Affiliate_Code_Output = {
+    __typename?: 'add_affiliate_code_output';
+    code_id: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+};
+/** columns and relationships of "affiliate_codes" */
+export type Affiliate_Codes = {
+    __typename?: 'affiliate_codes';
+    /** An object relationship */
+    affiliate: Affiliates;
+    affiliate_id: Scalars['uuid']['output'];
+    code: Scalars['String']['output'];
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    id: Scalars['uuid']['output'];
+    is_primary?: Maybe<Scalars['Boolean']['output']>;
+    redirect_path?: Maybe<Scalars['String']['output']>;
+};
+/** order by aggregate values of table "affiliate_codes" */
+export type Affiliate_Codes_Aggregate_Order_By = {
+    count?: InputMaybe<Order_By>;
+    max?: InputMaybe<Affiliate_Codes_Max_Order_By>;
+    min?: InputMaybe<Affiliate_Codes_Min_Order_By>;
+};
+/** Boolean expression to filter rows from the table "affiliate_codes". All fields are combined with a logical 'AND'. */
+export type Affiliate_Codes_Bool_Exp = {
+    _and?: InputMaybe<Array<Affiliate_Codes_Bool_Exp>>;
+    _not?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+    _or?: InputMaybe<Array<Affiliate_Codes_Bool_Exp>>;
+    affiliate?: InputMaybe<Affiliates_Bool_Exp>;
+    affiliate_id?: InputMaybe<Uuid_Comparison_Exp>;
+    code?: InputMaybe<String_Comparison_Exp>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    is_primary?: InputMaybe<Boolean_Comparison_Exp>;
+    redirect_path?: InputMaybe<String_Comparison_Exp>;
+};
+/** order by max() on columns of table "affiliate_codes" */
+export type Affiliate_Codes_Max_Order_By = {
+    affiliate_id?: InputMaybe<Order_By>;
+    code?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    redirect_path?: InputMaybe<Order_By>;
+};
+/** order by min() on columns of table "affiliate_codes" */
+export type Affiliate_Codes_Min_Order_By = {
+    affiliate_id?: InputMaybe<Order_By>;
+    code?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    redirect_path?: InputMaybe<Order_By>;
+};
+/** response of any mutation on the table "affiliate_codes" */
+export type Affiliate_Codes_Mutation_Response = {
+    __typename?: 'affiliate_codes_mutation_response';
+    /** number of rows affected by the mutation */
+    affected_rows: Scalars['Int']['output'];
+    /** data from the rows affected by the mutation */
+    returning: Array<Affiliate_Codes>;
+};
+/** Ordering options when selecting data from "affiliate_codes". */
+export type Affiliate_Codes_Order_By = {
+    affiliate?: InputMaybe<Affiliates_Order_By>;
+    affiliate_id?: InputMaybe<Order_By>;
+    code?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    is_primary?: InputMaybe<Order_By>;
+    redirect_path?: InputMaybe<Order_By>;
+};
+/** primary key columns input for table: affiliate_codes */
+export type Affiliate_Codes_Pk_Columns_Input = {
+    id: Scalars['uuid']['input'];
+};
+/** select columns of table "affiliate_codes" */
+export declare enum Affiliate_Codes_Select_Column {
+    /** column name */
+    AffiliateId = "affiliate_id",
+    /** column name */
+    Code = "code",
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    Id = "id",
+    /** column name */
+    IsPrimary = "is_primary",
+    /** column name */
+    RedirectPath = "redirect_path"
+}
+/** input type for updating data in table "affiliate_codes" */
+export type Affiliate_Codes_Set_Input = {
+    redirect_path?: InputMaybe<Scalars['String']['input']>;
+};
+/** Streaming cursor of the table "affiliate_codes" */
+export type Affiliate_Codes_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Affiliate_Codes_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Affiliate_Codes_Stream_Cursor_Value_Input = {
+    affiliate_id?: InputMaybe<Scalars['uuid']['input']>;
+    code?: InputMaybe<Scalars['String']['input']>;
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    is_primary?: InputMaybe<Scalars['Boolean']['input']>;
+    redirect_path?: InputMaybe<Scalars['String']['input']>;
+};
+export type Affiliate_Codes_Updates = {
+    /** sets the columns of the filtered rows to the given values */
+    _set?: InputMaybe<Affiliate_Codes_Set_Input>;
+    /** filter the rows which have to be updated */
+    where: Affiliate_Codes_Bool_Exp;
+};
+/** columns and relationships of "affiliates" */
+export type Affiliates = {
+    __typename?: 'affiliates';
+    /** An array relationship */
+    codes: Array<Affiliate_Codes>;
+    commission_percent?: Maybe<Scalars['Int']['output']>;
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    id: Scalars['uuid']['output'];
+    is_active?: Maybe<Scalars['Boolean']['output']>;
+    whop_affiliate_id?: Maybe<Scalars['String']['output']>;
+};
+/** columns and relationships of "affiliates" */
+export type AffiliatesCodesArgs = {
+    distinct_on?: InputMaybe<Array<Affiliate_Codes_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Affiliate_Codes_Order_By>>;
+    where?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+};
+/** Boolean expression to filter rows from the table "affiliates". All fields are combined with a logical 'AND'. */
+export type Affiliates_Bool_Exp = {
+    _and?: InputMaybe<Array<Affiliates_Bool_Exp>>;
+    _not?: InputMaybe<Affiliates_Bool_Exp>;
+    _or?: InputMaybe<Array<Affiliates_Bool_Exp>>;
+    codes?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+    commission_percent?: InputMaybe<Int_Comparison_Exp>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    is_active?: InputMaybe<Boolean_Comparison_Exp>;
+    whop_affiliate_id?: InputMaybe<String_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "affiliates". */
+export type Affiliates_Order_By = {
+    codes_aggregate?: InputMaybe<Affiliate_Codes_Aggregate_Order_By>;
+    commission_percent?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    is_active?: InputMaybe<Order_By>;
+    whop_affiliate_id?: InputMaybe<Order_By>;
+};
+/** select columns of table "affiliates" */
+export declare enum Affiliates_Select_Column {
+    /** column name */
+    CommissionPercent = "commission_percent",
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    Id = "id",
+    /** column name */
+    IsActive = "is_active",
+    /** column name */
+    WhopAffiliateId = "whop_affiliate_id"
+}
+/** Streaming cursor of the table "affiliates" */
+export type Affiliates_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Affiliates_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Affiliates_Stream_Cursor_Value_Input = {
+    commission_percent?: InputMaybe<Scalars['Int']['input']>;
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    is_active?: InputMaybe<Scalars['Boolean']['input']>;
+    whop_affiliate_id?: InputMaybe<Scalars['String']['input']>;
+};
+/** columns and relationships of "assets" */
+export type Assets = {
+    __typename?: 'assets';
+    created_at: Scalars['timestamptz']['output'];
+    id: Scalars['uuid']['output'];
+    metadata?: Maybe<Scalars['jsonb']['output']>;
+    /** An object relationship */
+    pipeline_run?: Maybe<Pipeline_Runs>;
+    pipeline_run_id?: Maybe<Scalars['uuid']['output']>;
+    tags: Array<Scalars['String']['output']>;
+    thumbnail_url?: Maybe<Scalars['String']['output']>;
+    type: Scalars['String']['output'];
+    url: Scalars['String']['output'];
+};
+/** columns and relationships of "assets" */
+export type AssetsMetadataArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** aggregated selection of "assets" */
+export type Assets_Aggregate = {
+    __typename?: 'assets_aggregate';
+    aggregate?: Maybe<Assets_Aggregate_Fields>;
+    nodes: Array<Assets>;
+};
+export type Assets_Aggregate_Bool_Exp = {
+    count?: InputMaybe<Assets_Aggregate_Bool_Exp_Count>;
+};
+export type Assets_Aggregate_Bool_Exp_Count = {
+    arguments?: InputMaybe<Array<Assets_Select_Column>>;
+    distinct?: InputMaybe<Scalars['Boolean']['input']>;
+    filter?: InputMaybe<Assets_Bool_Exp>;
+    predicate: Int_Comparison_Exp;
+};
+/** aggregate fields of "assets" */
+export type Assets_Aggregate_Fields = {
+    __typename?: 'assets_aggregate_fields';
+    count: Scalars['Int']['output'];
+    max?: Maybe<Assets_Max_Fields>;
+    min?: Maybe<Assets_Min_Fields>;
+};
+/** aggregate fields of "assets" */
+export type Assets_Aggregate_FieldsCountArgs = {
+    columns?: InputMaybe<Array<Assets_Select_Column>>;
+    distinct?: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** order by aggregate values of table "assets" */
+export type Assets_Aggregate_Order_By = {
+    count?: InputMaybe<Order_By>;
+    max?: InputMaybe<Assets_Max_Order_By>;
+    min?: InputMaybe<Assets_Min_Order_By>;
+};
+/** Boolean expression to filter rows from the table "assets". All fields are combined with a logical 'AND'. */
+export type Assets_Bool_Exp = {
+    _and?: InputMaybe<Array<Assets_Bool_Exp>>;
+    _not?: InputMaybe<Assets_Bool_Exp>;
+    _or?: InputMaybe<Array<Assets_Bool_Exp>>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    metadata?: InputMaybe<Jsonb_Comparison_Exp>;
+    pipeline_run?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+    pipeline_run_id?: InputMaybe<Uuid_Comparison_Exp>;
+    tags?: InputMaybe<String_Array_Comparison_Exp>;
+    thumbnail_url?: InputMaybe<String_Comparison_Exp>;
+    type?: InputMaybe<String_Comparison_Exp>;
+    url?: InputMaybe<String_Comparison_Exp>;
+};
+/** aggregate max on columns */
+export type Assets_Max_Fields = {
+    __typename?: 'assets_max_fields';
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    id?: Maybe<Scalars['uuid']['output']>;
+    pipeline_run_id?: Maybe<Scalars['uuid']['output']>;
+    tags?: Maybe<Array<Scalars['String']['output']>>;
+    thumbnail_url?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+/** order by max() on columns of table "assets" */
+export type Assets_Max_Order_By = {
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    pipeline_run_id?: InputMaybe<Order_By>;
+    tags?: InputMaybe<Order_By>;
+    thumbnail_url?: InputMaybe<Order_By>;
+    type?: InputMaybe<Order_By>;
+    url?: InputMaybe<Order_By>;
+};
+/** aggregate min on columns */
+export type Assets_Min_Fields = {
+    __typename?: 'assets_min_fields';
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    id?: Maybe<Scalars['uuid']['output']>;
+    pipeline_run_id?: Maybe<Scalars['uuid']['output']>;
+    tags?: Maybe<Array<Scalars['String']['output']>>;
+    thumbnail_url?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+/** order by min() on columns of table "assets" */
+export type Assets_Min_Order_By = {
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    pipeline_run_id?: InputMaybe<Order_By>;
+    tags?: InputMaybe<Order_By>;
+    thumbnail_url?: InputMaybe<Order_By>;
+    type?: InputMaybe<Order_By>;
+    url?: InputMaybe<Order_By>;
+};
+/** response of any mutation on the table "assets" */
+export type Assets_Mutation_Response = {
+    __typename?: 'assets_mutation_response';
+    /** number of rows affected by the mutation */
+    affected_rows: Scalars['Int']['output'];
+    /** data from the rows affected by the mutation */
+    returning: Array<Assets>;
+};
+/** Ordering options when selecting data from "assets". */
+export type Assets_Order_By = {
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    metadata?: InputMaybe<Order_By>;
+    pipeline_run?: InputMaybe<Pipeline_Runs_Order_By>;
+    pipeline_run_id?: InputMaybe<Order_By>;
+    tags?: InputMaybe<Order_By>;
+    thumbnail_url?: InputMaybe<Order_By>;
+    type?: InputMaybe<Order_By>;
+    url?: InputMaybe<Order_By>;
+};
+/** primary key columns input for table: assets */
+export type Assets_Pk_Columns_Input = {
+    id: Scalars['uuid']['input'];
+};
+/** select columns of table "assets" */
+export declare enum Assets_Select_Column {
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    Id = "id",
+    /** column name */
+    Metadata = "metadata",
+    /** column name */
+    PipelineRunId = "pipeline_run_id",
+    /** column name */
+    Tags = "tags",
+    /** column name */
+    ThumbnailUrl = "thumbnail_url",
+    /** column name */
+    Type = "type",
+    /** column name */
+    Url = "url"
+}
+/** input type for updating data in table "assets" */
+export type Assets_Set_Input = {
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+/** Streaming cursor of the table "assets" */
+export type Assets_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Assets_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Assets_Stream_Cursor_Value_Input = {
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    metadata?: InputMaybe<Scalars['jsonb']['input']>;
+    pipeline_run_id?: InputMaybe<Scalars['uuid']['input']>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    thumbnail_url?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['String']['input']>;
+};
+export type Assets_Updates = {
+    /** sets the columns of the filtered rows to the given values */
+    _set?: InputMaybe<Assets_Set_Input>;
+    /** filter the rows which have to be updated */
+    where: Assets_Bool_Exp;
+};
+export type Auth_Flow = {
+    __typename?: 'auth_flow';
+    csrf_token: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+};
+export type Auth_Result = {
+    __typename?: 'auth_result';
+    message: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+    token?: Maybe<Scalars['String']['output']>;
+    whop_affiliate_id?: Maybe<Scalars['String']['output']>;
+};
+/** Boolean expression to compare columns of type "bpchar". All fields are combined with logical 'AND'. */
+export type Bpchar_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['bpchar']['input']>;
+    _gt?: InputMaybe<Scalars['bpchar']['input']>;
+    _gte?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column match the given case-insensitive pattern */
+    _ilike?: InputMaybe<Scalars['bpchar']['input']>;
+    _in?: InputMaybe<Array<Scalars['bpchar']['input']>>;
+    /** does the column match the given POSIX regular expression, case insensitive */
+    _iregex?: InputMaybe<Scalars['bpchar']['input']>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    /** does the column match the given pattern */
+    _like?: InputMaybe<Scalars['bpchar']['input']>;
+    _lt?: InputMaybe<Scalars['bpchar']['input']>;
+    _lte?: InputMaybe<Scalars['bpchar']['input']>;
+    _neq?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column NOT match the given case-insensitive pattern */
+    _nilike?: InputMaybe<Scalars['bpchar']['input']>;
+    _nin?: InputMaybe<Array<Scalars['bpchar']['input']>>;
+    /** does the column NOT match the given POSIX regular expression, case insensitive */
+    _niregex?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column NOT match the given pattern */
+    _nlike?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column NOT match the given POSIX regular expression, case sensitive */
+    _nregex?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column NOT match the given SQL regular expression */
+    _nsimilar?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column match the given POSIX regular expression, case sensitive */
+    _regex?: InputMaybe<Scalars['bpchar']['input']>;
+    /** does the column match the given SQL regular expression */
+    _similar?: InputMaybe<Scalars['bpchar']['input']>;
+};
+export type Create_Asset_Output = {
+    __typename?: 'create_asset_output';
+    created_at: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    tags: Array<Scalars['String']['output']>;
+    type: Scalars['String']['output'];
+    url: Scalars['String']['output'];
+};
+export type Create_Personal_Access_Token_Output = {
+    __typename?: 'create_personal_access_token_output';
+    expires_at: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    jti: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+    token: Scalars['String']['output'];
+};
+export type Credit_Balance_Output = {
+    __typename?: 'credit_balance_output';
+    available: Scalars['Int']['output'];
+    balance: Scalars['Int']['output'];
+    reserved: Scalars['Int']['output'];
+};
+export type Credit_History_Entry = {
+    __typename?: 'credit_history_entry';
+    amount: Scalars['Int']['output'];
+    created_at: Scalars['String']['output'];
+    description: Scalars['String']['output'];
+    type: Scalars['String']['output'];
+};
+/** columns and relationships of "credit_packs" */
+export type Credit_Packs = {
+    __typename?: 'credit_packs';
+    credits: Scalars['Int']['output'];
+    id: Scalars['uuid']['output'];
+    name: Scalars['String']['output'];
+    price_cents: Scalars['Int']['output'];
+    slug: Scalars['String']['output'];
+    sort_order: Scalars['Int']['output'];
+    whop_plan_id?: Maybe<Scalars['String']['output']>;
+};
+/** Boolean expression to filter rows from the table "credit_packs". All fields are combined with a logical 'AND'. */
+export type Credit_Packs_Bool_Exp = {
+    _and?: InputMaybe<Array<Credit_Packs_Bool_Exp>>;
+    _not?: InputMaybe<Credit_Packs_Bool_Exp>;
+    _or?: InputMaybe<Array<Credit_Packs_Bool_Exp>>;
+    credits?: InputMaybe<Int_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    name?: InputMaybe<String_Comparison_Exp>;
+    price_cents?: InputMaybe<Int_Comparison_Exp>;
+    slug?: InputMaybe<String_Comparison_Exp>;
+    sort_order?: InputMaybe<Int_Comparison_Exp>;
+    whop_plan_id?: InputMaybe<String_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "credit_packs". */
+export type Credit_Packs_Order_By = {
+    credits?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    name?: InputMaybe<Order_By>;
+    price_cents?: InputMaybe<Order_By>;
+    slug?: InputMaybe<Order_By>;
+    sort_order?: InputMaybe<Order_By>;
+    whop_plan_id?: InputMaybe<Order_By>;
+};
+/** select columns of table "credit_packs" */
+export declare enum Credit_Packs_Select_Column {
+    /** column name */
+    Credits = "credits",
+    /** column name */
+    Id = "id",
+    /** column name */
+    Name = "name",
+    /** column name */
+    PriceCents = "price_cents",
+    /** column name */
+    Slug = "slug",
+    /** column name */
+    SortOrder = "sort_order",
+    /** column name */
+    WhopPlanId = "whop_plan_id"
+}
+/** Streaming cursor of the table "credit_packs" */
+export type Credit_Packs_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Credit_Packs_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Credit_Packs_Stream_Cursor_Value_Input = {
+    credits?: InputMaybe<Scalars['Int']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    price_cents?: InputMaybe<Scalars['Int']['input']>;
+    slug?: InputMaybe<Scalars['String']['input']>;
+    sort_order?: InputMaybe<Scalars['Int']['input']>;
+    whop_plan_id?: InputMaybe<Scalars['String']['input']>;
+};
+export type Current_User_Output = {
+    __typename?: 'current_user_output';
+    avatar_url?: Maybe<Scalars['String']['output']>;
+    email: Scalars['String']['output'];
+    email_verified: Scalars['Boolean']['output'];
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+};
+/** ordering argument of a cursor */
+export declare enum Cursor_Ordering {
+    /** ascending ordering of the cursor */
+    Asc = "ASC",
+    /** descending ordering of the cursor */
+    Desc = "DESC"
+}
+export type Delete_Asset_Output = {
+    __typename?: 'delete_asset_output';
+    success: Scalars['Boolean']['output'];
+};
+export type Ensure_Affiliate_Output = {
+    __typename?: 'ensure_affiliate_output';
+    affiliate_id: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+};
+/** columns and relationships of "executions_visibility" */
+export type Executions_Visibility = {
+    __typename?: 'executions_visibility';
+    close_time?: Maybe<Scalars['timestamp']['output']>;
+    run_id: Scalars['bpchar']['output'];
+    start_time: Scalars['timestamp']['output'];
+    status: Scalars['Int']['output'];
+    task_queue: Scalars['String']['output'];
+    workflow_id: Scalars['String']['output'];
+    workflow_type_name: Scalars['String']['output'];
+};
+/** Boolean expression to filter rows from the table "executions_visibility". All fields are combined with a logical 'AND'. */
+export type Executions_Visibility_Bool_Exp = {
+    _and?: InputMaybe<Array<Executions_Visibility_Bool_Exp>>;
+    _not?: InputMaybe<Executions_Visibility_Bool_Exp>;
+    _or?: InputMaybe<Array<Executions_Visibility_Bool_Exp>>;
+    close_time?: InputMaybe<Timestamp_Comparison_Exp>;
+    run_id?: InputMaybe<Bpchar_Comparison_Exp>;
+    start_time?: InputMaybe<Timestamp_Comparison_Exp>;
+    status?: InputMaybe<Int_Comparison_Exp>;
+    task_queue?: InputMaybe<String_Comparison_Exp>;
+    workflow_id?: InputMaybe<String_Comparison_Exp>;
+    workflow_type_name?: InputMaybe<String_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "executions_visibility". */
+export type Executions_Visibility_Order_By = {
+    close_time?: InputMaybe<Order_By>;
+    run_id?: InputMaybe<Order_By>;
+    start_time?: InputMaybe<Order_By>;
+    status?: InputMaybe<Order_By>;
+    task_queue?: InputMaybe<Order_By>;
+    workflow_id?: InputMaybe<Order_By>;
+    workflow_type_name?: InputMaybe<Order_By>;
+};
+/** select columns of table "executions_visibility" */
+export declare enum Executions_Visibility_Select_Column {
+    /** column name */
+    CloseTime = "close_time",
+    /** column name */
+    RunId = "run_id",
+    /** column name */
+    StartTime = "start_time",
+    /** column name */
+    Status = "status",
+    /** column name */
+    TaskQueue = "task_queue",
+    /** column name */
+    WorkflowId = "workflow_id",
+    /** column name */
+    WorkflowTypeName = "workflow_type_name"
+}
+/** Streaming cursor of the table "executions_visibility" */
+export type Executions_Visibility_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Executions_Visibility_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Executions_Visibility_Stream_Cursor_Value_Input = {
+    close_time?: InputMaybe<Scalars['timestamp']['input']>;
+    run_id?: InputMaybe<Scalars['bpchar']['input']>;
+    start_time?: InputMaybe<Scalars['timestamp']['input']>;
+    status?: InputMaybe<Scalars['Int']['input']>;
+    task_queue?: InputMaybe<Scalars['String']['input']>;
+    workflow_id?: InputMaybe<Scalars['String']['input']>;
+    workflow_type_name?: InputMaybe<Scalars['String']['input']>;
+};
+export type Get_My_Referrals_Output = {
+    __typename?: 'get_my_referrals_output';
+    active_referrals: Scalars['Int']['output'];
+    referrals: Array<Referral_Entry>;
+    total_commission_cents: Scalars['Int']['output'];
+    total_referrals: Scalars['Int']['output'];
+};
+export type Jsonb_Cast_Exp = {
+    String?: InputMaybe<String_Comparison_Exp>;
+};
+/** Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'. */
+export type Jsonb_Comparison_Exp = {
+    _cast?: InputMaybe<Jsonb_Cast_Exp>;
+    /** is the column contained in the given json value */
+    _contained_in?: InputMaybe<Scalars['jsonb']['input']>;
+    /** does the column contain the given json value at the top level */
+    _contains?: InputMaybe<Scalars['jsonb']['input']>;
+    _eq?: InputMaybe<Scalars['jsonb']['input']>;
+    _gt?: InputMaybe<Scalars['jsonb']['input']>;
+    _gte?: InputMaybe<Scalars['jsonb']['input']>;
+    /** does the string exist as a top-level key in the column */
+    _has_key?: InputMaybe<Scalars['String']['input']>;
+    /** do all of these strings exist as top-level keys in the column */
+    _has_keys_all?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** do any of these strings exist as top-level keys in the column */
+    _has_keys_any?: InputMaybe<Array<Scalars['String']['input']>>;
+    _in?: InputMaybe<Array<Scalars['jsonb']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['jsonb']['input']>;
+    _lte?: InputMaybe<Scalars['jsonb']['input']>;
+    _neq?: InputMaybe<Scalars['jsonb']['input']>;
+    _nin?: InputMaybe<Array<Scalars['jsonb']['input']>>;
+};
+/** mutation root */
+export type Mutation_Root = {
+    __typename?: 'mutation_root';
+    /** Add a new primary affiliate code */
+    add_affiliate_code: Add_Affiliate_Code_Output;
+    /** Create an asset record after S3 upload */
+    create_asset: Create_Asset_Output;
+    /** Create a new personal access token for API/MCP authentication */
+    create_personal_access_token: Create_Personal_Access_Token_Output;
+    /** Delete an asset and its S3 object */
+    delete_asset: Delete_Asset_Output;
+    /** Create affiliate record and referral code for current user if missing */
+    ensure_affiliate: Ensure_Affiliate_Output;
+    /** Initiate Kratos login flow */
+    init_login_flow: Auth_Flow;
+    /** Initiate Kratos password recovery (forgot password) flow */
+    init_recovery_flow: Auth_Result;
+    /** Initiate Kratos signup (registration) flow */
+    init_signup_flow: Auth_Flow;
+    /** Initiate Kratos email verification flow */
+    init_verification_flow: Auth_Flow;
+    /** Generate presigned S3 PUT URL for direct browser uploads */
+    request_upload: Request_Upload_Output;
+    /** Revoke a personal access token */
+    revoke_personal_access_token: Revoke_Personal_Access_Token_Output;
+    /** Start a pipeline execution via Temporal workflow */
+    run_pipeline?: Maybe<Run_Pipeline_Output>;
+    /** Submit Kratos login credentials */
+    submit_login_flow: Auth_Result;
+    /** Submit Kratos password recovery (set new password) */
+    submit_recovery_flow: Auth_Result;
+    /** Submit Kratos signup (registration) form */
+    submit_signup_flow: Auth_Result;
+    /** Initiate OIDC social login flow and return provider redirect URL */
+    submit_social_login: Social_Login_Output;
+    /** Submit Kratos verification code */
+    submit_verification_code: Auth_Result;
+    /** update data of the table: "affiliate_codes" */
+    update_affiliate_codes?: Maybe<Affiliate_Codes_Mutation_Response>;
+    /** update single row of the table: "affiliate_codes" */
+    update_affiliate_codes_by_pk?: Maybe<Affiliate_Codes>;
+    /** update multiples rows of table: "affiliate_codes" */
+    update_affiliate_codes_many?: Maybe<Array<Maybe<Affiliate_Codes_Mutation_Response>>>;
+    /** update data of the table: "assets" */
+    update_assets?: Maybe<Assets_Mutation_Response>;
+    /** update single row of the table: "assets" */
+    update_assets_by_pk?: Maybe<Assets>;
+    /** update multiples rows of table: "assets" */
+    update_assets_many?: Maybe<Array<Maybe<Assets_Mutation_Response>>>;
+};
+/** mutation root */
+export type Mutation_RootAdd_Affiliate_CodeArgs = {
+    code: Scalars['String']['input'];
+    redirect_path?: InputMaybe<Scalars['String']['input']>;
+};
+/** mutation root */
+export type Mutation_RootCreate_AssetArgs = {
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    type: Scalars['String']['input'];
+    url: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootCreate_Personal_Access_TokenArgs = {
+    name: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootDelete_AssetArgs = {
+    id: Scalars['uuid']['input'];
+};
+/** mutation root */
+export type Mutation_RootInit_Recovery_FlowArgs = {
+    email: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootInit_Verification_FlowArgs = {
+    email?: InputMaybe<Scalars['String']['input']>;
+};
+/** mutation root */
+export type Mutation_RootRequest_UploadArgs = {
+    content_type: Scalars['String']['input'];
+    filename: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootRevoke_Personal_Access_TokenArgs = {
+    id: Scalars['uuid']['input'];
+};
+/** mutation root */
+export type Mutation_RootRun_PipelineArgs = {
+    input: Scalars['jsonb']['input'];
+    pipeline_slug: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootSubmit_Login_FlowArgs = {
+    csrf_token: Scalars['String']['input'];
+    email: Scalars['String']['input'];
+    flowId: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    referral_code?: InputMaybe<Scalars['String']['input']>;
+};
+/** mutation root */
+export type Mutation_RootSubmit_Recovery_FlowArgs = {
+    csrf_token: Scalars['String']['input'];
+    flowId: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootSubmit_Signup_FlowArgs = {
+    csrf_token: Scalars['String']['input'];
+    email: Scalars['String']['input'];
+    flowId: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootSubmit_Social_LoginArgs = {
+    provider: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootSubmit_Verification_CodeArgs = {
+    code: Scalars['String']['input'];
+    csrf_token: Scalars['String']['input'];
+    flowId: Scalars['String']['input'];
+};
+/** mutation root */
+export type Mutation_RootUpdate_Affiliate_CodesArgs = {
+    _set?: InputMaybe<Affiliate_Codes_Set_Input>;
+    where: Affiliate_Codes_Bool_Exp;
+};
+/** mutation root */
+export type Mutation_RootUpdate_Affiliate_Codes_By_PkArgs = {
+    _set?: InputMaybe<Affiliate_Codes_Set_Input>;
+    pk_columns: Affiliate_Codes_Pk_Columns_Input;
+};
+/** mutation root */
+export type Mutation_RootUpdate_Affiliate_Codes_ManyArgs = {
+    updates: Array<Affiliate_Codes_Updates>;
+};
+/** mutation root */
+export type Mutation_RootUpdate_AssetsArgs = {
+    _set?: InputMaybe<Assets_Set_Input>;
+    where: Assets_Bool_Exp;
+};
+/** mutation root */
+export type Mutation_RootUpdate_Assets_By_PkArgs = {
+    _set?: InputMaybe<Assets_Set_Input>;
+    pk_columns: Assets_Pk_Columns_Input;
+};
+/** mutation root */
+export type Mutation_RootUpdate_Assets_ManyArgs = {
+    updates: Array<Assets_Updates>;
+};
+/** column ordering options */
+export declare enum Order_By {
+    /** in ascending order, nulls last */
+    Asc = "asc",
+    /** in ascending order, nulls first */
+    AscNullsFirst = "asc_nulls_first",
+    /** in ascending order, nulls last */
+    AscNullsLast = "asc_nulls_last",
+    /** in descending order, nulls first */
+    Desc = "desc",
+    /** in descending order, nulls first */
+    DescNullsFirst = "desc_nulls_first",
+    /** in descending order, nulls last */
+    DescNullsLast = "desc_nulls_last"
+}
+/** columns and relationships of "personal_access_tokens" */
+export type Personal_Access_Tokens = {
+    __typename?: 'personal_access_tokens';
+    created_at: Scalars['timestamptz']['output'];
+    expires_at: Scalars['timestamptz']['output'];
+    id: Scalars['uuid']['output'];
+    last_used_at?: Maybe<Scalars['timestamptz']['output']>;
+    name: Scalars['String']['output'];
+    revoked_at?: Maybe<Scalars['timestamptz']['output']>;
+    scopes: Array<Scalars['String']['output']>;
+};
+/** Boolean expression to filter rows from the table "personal_access_tokens". All fields are combined with a logical 'AND'. */
+export type Personal_Access_Tokens_Bool_Exp = {
+    _and?: InputMaybe<Array<Personal_Access_Tokens_Bool_Exp>>;
+    _not?: InputMaybe<Personal_Access_Tokens_Bool_Exp>;
+    _or?: InputMaybe<Array<Personal_Access_Tokens_Bool_Exp>>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    expires_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    last_used_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    name?: InputMaybe<String_Comparison_Exp>;
+    revoked_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    scopes?: InputMaybe<String_Array_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "personal_access_tokens". */
+export type Personal_Access_Tokens_Order_By = {
+    created_at?: InputMaybe<Order_By>;
+    expires_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    last_used_at?: InputMaybe<Order_By>;
+    name?: InputMaybe<Order_By>;
+    revoked_at?: InputMaybe<Order_By>;
+    scopes?: InputMaybe<Order_By>;
+};
+/** select columns of table "personal_access_tokens" */
+export declare enum Personal_Access_Tokens_Select_Column {
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    ExpiresAt = "expires_at",
+    /** column name */
+    Id = "id",
+    /** column name */
+    LastUsedAt = "last_used_at",
+    /** column name */
+    Name = "name",
+    /** column name */
+    RevokedAt = "revoked_at",
+    /** column name */
+    Scopes = "scopes"
+}
+/** Streaming cursor of the table "personal_access_tokens" */
+export type Personal_Access_Tokens_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Personal_Access_Tokens_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Personal_Access_Tokens_Stream_Cursor_Value_Input = {
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    expires_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    last_used_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    revoked_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    scopes?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+/** columns and relationships of "pipeline_runs" */
+export type Pipeline_Runs = {
+    __typename?: 'pipeline_runs';
+    /** An array relationship */
+    assets: Array<Assets>;
+    /** An aggregate relationship */
+    assets_aggregate: Assets_Aggregate;
+    completed_at?: Maybe<Scalars['timestamptz']['output']>;
+    created_at: Scalars['timestamptz']['output'];
+    credits_charged?: Maybe<Scalars['Int']['output']>;
+    error_message?: Maybe<Scalars['String']['output']>;
+    id: Scalars['uuid']['output'];
+    input: Scalars['jsonb']['output'];
+    output?: Maybe<Scalars['jsonb']['output']>;
+    /** An object relationship */
+    pipeline: Pipelines;
+    pipeline_id: Scalars['uuid']['output'];
+    started_at?: Maybe<Scalars['timestamptz']['output']>;
+    status: Scalars['String']['output'];
+    temporal_workflow_id?: Maybe<Scalars['String']['output']>;
+    workflow_execution?: Maybe<Executions_Visibility>;
+};
+/** columns and relationships of "pipeline_runs" */
+export type Pipeline_RunsAssetsArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+/** columns and relationships of "pipeline_runs" */
+export type Pipeline_RunsAssets_AggregateArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+/** columns and relationships of "pipeline_runs" */
+export type Pipeline_RunsInputArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** columns and relationships of "pipeline_runs" */
+export type Pipeline_RunsOutputArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** aggregated selection of "pipeline_runs" */
+export type Pipeline_Runs_Aggregate = {
+    __typename?: 'pipeline_runs_aggregate';
+    aggregate?: Maybe<Pipeline_Runs_Aggregate_Fields>;
+    nodes: Array<Pipeline_Runs>;
+};
+/** aggregate fields of "pipeline_runs" */
+export type Pipeline_Runs_Aggregate_Fields = {
+    __typename?: 'pipeline_runs_aggregate_fields';
+    avg?: Maybe<Pipeline_Runs_Avg_Fields>;
+    count: Scalars['Int']['output'];
+    max?: Maybe<Pipeline_Runs_Max_Fields>;
+    min?: Maybe<Pipeline_Runs_Min_Fields>;
+    stddev?: Maybe<Pipeline_Runs_Stddev_Fields>;
+    stddev_pop?: Maybe<Pipeline_Runs_Stddev_Pop_Fields>;
+    stddev_samp?: Maybe<Pipeline_Runs_Stddev_Samp_Fields>;
+    sum?: Maybe<Pipeline_Runs_Sum_Fields>;
+    var_pop?: Maybe<Pipeline_Runs_Var_Pop_Fields>;
+    var_samp?: Maybe<Pipeline_Runs_Var_Samp_Fields>;
+    variance?: Maybe<Pipeline_Runs_Variance_Fields>;
+};
+/** aggregate fields of "pipeline_runs" */
+export type Pipeline_Runs_Aggregate_FieldsCountArgs = {
+    columns?: InputMaybe<Array<Pipeline_Runs_Select_Column>>;
+    distinct?: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** aggregate avg on columns */
+export type Pipeline_Runs_Avg_Fields = {
+    __typename?: 'pipeline_runs_avg_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** Boolean expression to filter rows from the table "pipeline_runs". All fields are combined with a logical 'AND'. */
+export type Pipeline_Runs_Bool_Exp = {
+    _and?: InputMaybe<Array<Pipeline_Runs_Bool_Exp>>;
+    _not?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+    _or?: InputMaybe<Array<Pipeline_Runs_Bool_Exp>>;
+    assets?: InputMaybe<Assets_Bool_Exp>;
+    assets_aggregate?: InputMaybe<Assets_Aggregate_Bool_Exp>;
+    completed_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    credits_charged?: InputMaybe<Int_Comparison_Exp>;
+    error_message?: InputMaybe<String_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    input?: InputMaybe<Jsonb_Comparison_Exp>;
+    output?: InputMaybe<Jsonb_Comparison_Exp>;
+    pipeline?: InputMaybe<Pipelines_Bool_Exp>;
+    pipeline_id?: InputMaybe<Uuid_Comparison_Exp>;
+    started_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    status?: InputMaybe<String_Comparison_Exp>;
+    temporal_workflow_id?: InputMaybe<String_Comparison_Exp>;
+};
+/** aggregate max on columns */
+export type Pipeline_Runs_Max_Fields = {
+    __typename?: 'pipeline_runs_max_fields';
+    completed_at?: Maybe<Scalars['timestamptz']['output']>;
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    credits_charged?: Maybe<Scalars['Int']['output']>;
+    error_message?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['uuid']['output']>;
+    pipeline_id?: Maybe<Scalars['uuid']['output']>;
+    started_at?: Maybe<Scalars['timestamptz']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+    temporal_workflow_id?: Maybe<Scalars['String']['output']>;
+};
+/** aggregate min on columns */
+export type Pipeline_Runs_Min_Fields = {
+    __typename?: 'pipeline_runs_min_fields';
+    completed_at?: Maybe<Scalars['timestamptz']['output']>;
+    created_at?: Maybe<Scalars['timestamptz']['output']>;
+    credits_charged?: Maybe<Scalars['Int']['output']>;
+    error_message?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['uuid']['output']>;
+    pipeline_id?: Maybe<Scalars['uuid']['output']>;
+    started_at?: Maybe<Scalars['timestamptz']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+    temporal_workflow_id?: Maybe<Scalars['String']['output']>;
+};
+/** Ordering options when selecting data from "pipeline_runs". */
+export type Pipeline_Runs_Order_By = {
+    assets_aggregate?: InputMaybe<Assets_Aggregate_Order_By>;
+    completed_at?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    credits_charged?: InputMaybe<Order_By>;
+    error_message?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    input?: InputMaybe<Order_By>;
+    output?: InputMaybe<Order_By>;
+    pipeline?: InputMaybe<Pipelines_Order_By>;
+    pipeline_id?: InputMaybe<Order_By>;
+    started_at?: InputMaybe<Order_By>;
+    status?: InputMaybe<Order_By>;
+    temporal_workflow_id?: InputMaybe<Order_By>;
+};
+/** select columns of table "pipeline_runs" */
+export declare enum Pipeline_Runs_Select_Column {
+    /** column name */
+    CompletedAt = "completed_at",
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    CreditsCharged = "credits_charged",
+    /** column name */
+    ErrorMessage = "error_message",
+    /** column name */
+    Id = "id",
+    /** column name */
+    Input = "input",
+    /** column name */
+    Output = "output",
+    /** column name */
+    PipelineId = "pipeline_id",
+    /** column name */
+    StartedAt = "started_at",
+    /** column name */
+    Status = "status",
+    /** column name */
+    TemporalWorkflowId = "temporal_workflow_id"
+}
+/** aggregate stddev on columns */
+export type Pipeline_Runs_Stddev_Fields = {
+    __typename?: 'pipeline_runs_stddev_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** aggregate stddev_pop on columns */
+export type Pipeline_Runs_Stddev_Pop_Fields = {
+    __typename?: 'pipeline_runs_stddev_pop_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** aggregate stddev_samp on columns */
+export type Pipeline_Runs_Stddev_Samp_Fields = {
+    __typename?: 'pipeline_runs_stddev_samp_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** Streaming cursor of the table "pipeline_runs" */
+export type Pipeline_Runs_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Pipeline_Runs_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Pipeline_Runs_Stream_Cursor_Value_Input = {
+    completed_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    credits_charged?: InputMaybe<Scalars['Int']['input']>;
+    error_message?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    input?: InputMaybe<Scalars['jsonb']['input']>;
+    output?: InputMaybe<Scalars['jsonb']['input']>;
+    pipeline_id?: InputMaybe<Scalars['uuid']['input']>;
+    started_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    status?: InputMaybe<Scalars['String']['input']>;
+    temporal_workflow_id?: InputMaybe<Scalars['String']['input']>;
+};
+/** aggregate sum on columns */
+export type Pipeline_Runs_Sum_Fields = {
+    __typename?: 'pipeline_runs_sum_fields';
+    credits_charged?: Maybe<Scalars['Int']['output']>;
+};
+/** aggregate var_pop on columns */
+export type Pipeline_Runs_Var_Pop_Fields = {
+    __typename?: 'pipeline_runs_var_pop_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** aggregate var_samp on columns */
+export type Pipeline_Runs_Var_Samp_Fields = {
+    __typename?: 'pipeline_runs_var_samp_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** aggregate variance on columns */
+export type Pipeline_Runs_Variance_Fields = {
+    __typename?: 'pipeline_runs_variance_fields';
+    credits_charged?: Maybe<Scalars['Float']['output']>;
+};
+/** columns and relationships of "pipelines" */
+export type Pipelines = {
+    __typename?: 'pipelines';
+    category: Scalars['String']['output'];
+    credit_cost: Scalars['Int']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    icon_url?: Maybe<Scalars['String']['output']>;
+    id: Scalars['uuid']['output'];
+    input_schema: Scalars['jsonb']['output'];
+    name: Scalars['String']['output'];
+    output_schema: Scalars['jsonb']['output'];
+    preview_url?: Maybe<Scalars['String']['output']>;
+    required_providers: Array<Scalars['String']['output']>;
+    seo_content?: Maybe<Scalars['String']['output']>;
+    seo_faq?: Maybe<Scalars['jsonb']['output']>;
+    slug: Scalars['String']['output'];
+    sort_order: Scalars['Int']['output'];
+    ui_schema: Scalars['jsonb']['output'];
+};
+/** columns and relationships of "pipelines" */
+export type PipelinesInput_SchemaArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** columns and relationships of "pipelines" */
+export type PipelinesOutput_SchemaArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** columns and relationships of "pipelines" */
+export type PipelinesSeo_FaqArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** columns and relationships of "pipelines" */
+export type PipelinesUi_SchemaArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** Boolean expression to filter rows from the table "pipelines". All fields are combined with a logical 'AND'. */
+export type Pipelines_Bool_Exp = {
+    _and?: InputMaybe<Array<Pipelines_Bool_Exp>>;
+    _not?: InputMaybe<Pipelines_Bool_Exp>;
+    _or?: InputMaybe<Array<Pipelines_Bool_Exp>>;
+    category?: InputMaybe<String_Comparison_Exp>;
+    credit_cost?: InputMaybe<Int_Comparison_Exp>;
+    description?: InputMaybe<String_Comparison_Exp>;
+    icon_url?: InputMaybe<String_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    input_schema?: InputMaybe<Jsonb_Comparison_Exp>;
+    name?: InputMaybe<String_Comparison_Exp>;
+    output_schema?: InputMaybe<Jsonb_Comparison_Exp>;
+    preview_url?: InputMaybe<String_Comparison_Exp>;
+    required_providers?: InputMaybe<String_Array_Comparison_Exp>;
+    seo_content?: InputMaybe<String_Comparison_Exp>;
+    seo_faq?: InputMaybe<Jsonb_Comparison_Exp>;
+    slug?: InputMaybe<String_Comparison_Exp>;
+    sort_order?: InputMaybe<Int_Comparison_Exp>;
+    ui_schema?: InputMaybe<Jsonb_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "pipelines". */
+export type Pipelines_Order_By = {
+    category?: InputMaybe<Order_By>;
+    credit_cost?: InputMaybe<Order_By>;
+    description?: InputMaybe<Order_By>;
+    icon_url?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    input_schema?: InputMaybe<Order_By>;
+    name?: InputMaybe<Order_By>;
+    output_schema?: InputMaybe<Order_By>;
+    preview_url?: InputMaybe<Order_By>;
+    required_providers?: InputMaybe<Order_By>;
+    seo_content?: InputMaybe<Order_By>;
+    seo_faq?: InputMaybe<Order_By>;
+    slug?: InputMaybe<Order_By>;
+    sort_order?: InputMaybe<Order_By>;
+    ui_schema?: InputMaybe<Order_By>;
+};
+/** select columns of table "pipelines" */
+export declare enum Pipelines_Select_Column {
+    /** column name */
+    Category = "category",
+    /** column name */
+    CreditCost = "credit_cost",
+    /** column name */
+    Description = "description",
+    /** column name */
+    IconUrl = "icon_url",
+    /** column name */
+    Id = "id",
+    /** column name */
+    InputSchema = "input_schema",
+    /** column name */
+    Name = "name",
+    /** column name */
+    OutputSchema = "output_schema",
+    /** column name */
+    PreviewUrl = "preview_url",
+    /** column name */
+    RequiredProviders = "required_providers",
+    /** column name */
+    SeoContent = "seo_content",
+    /** column name */
+    SeoFaq = "seo_faq",
+    /** column name */
+    Slug = "slug",
+    /** column name */
+    SortOrder = "sort_order",
+    /** column name */
+    UiSchema = "ui_schema"
+}
+/** Streaming cursor of the table "pipelines" */
+export type Pipelines_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Pipelines_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Pipelines_Stream_Cursor_Value_Input = {
+    category?: InputMaybe<Scalars['String']['input']>;
+    credit_cost?: InputMaybe<Scalars['Int']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    icon_url?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    input_schema?: InputMaybe<Scalars['jsonb']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    output_schema?: InputMaybe<Scalars['jsonb']['input']>;
+    preview_url?: InputMaybe<Scalars['String']['input']>;
+    required_providers?: InputMaybe<Array<Scalars['String']['input']>>;
+    seo_content?: InputMaybe<Scalars['String']['input']>;
+    seo_faq?: InputMaybe<Scalars['jsonb']['input']>;
+    slug?: InputMaybe<Scalars['String']['input']>;
+    sort_order?: InputMaybe<Scalars['Int']['input']>;
+    ui_schema?: InputMaybe<Scalars['jsonb']['input']>;
+};
+/** columns and relationships of "plans" */
+export type Plans = {
+    __typename?: 'plans';
+    description?: Maybe<Scalars['String']['output']>;
+    features: Scalars['jsonb']['output'];
+    id: Scalars['uuid']['output'];
+    monthly_credits: Scalars['Int']['output'];
+    name: Scalars['String']['output'];
+    price_cents: Scalars['Int']['output'];
+    slug: Scalars['String']['output'];
+    sort_order: Scalars['Int']['output'];
+    whop_plan_id?: Maybe<Scalars['String']['output']>;
+};
+/** columns and relationships of "plans" */
+export type PlansFeaturesArgs = {
+    path?: InputMaybe<Scalars['String']['input']>;
+};
+/** Boolean expression to filter rows from the table "plans". All fields are combined with a logical 'AND'. */
+export type Plans_Bool_Exp = {
+    _and?: InputMaybe<Array<Plans_Bool_Exp>>;
+    _not?: InputMaybe<Plans_Bool_Exp>;
+    _or?: InputMaybe<Array<Plans_Bool_Exp>>;
+    description?: InputMaybe<String_Comparison_Exp>;
+    features?: InputMaybe<Jsonb_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    monthly_credits?: InputMaybe<Int_Comparison_Exp>;
+    name?: InputMaybe<String_Comparison_Exp>;
+    price_cents?: InputMaybe<Int_Comparison_Exp>;
+    slug?: InputMaybe<String_Comparison_Exp>;
+    sort_order?: InputMaybe<Int_Comparison_Exp>;
+    whop_plan_id?: InputMaybe<String_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "plans". */
+export type Plans_Order_By = {
+    description?: InputMaybe<Order_By>;
+    features?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    monthly_credits?: InputMaybe<Order_By>;
+    name?: InputMaybe<Order_By>;
+    price_cents?: InputMaybe<Order_By>;
+    slug?: InputMaybe<Order_By>;
+    sort_order?: InputMaybe<Order_By>;
+    whop_plan_id?: InputMaybe<Order_By>;
+};
+/** select columns of table "plans" */
+export declare enum Plans_Select_Column {
+    /** column name */
+    Description = "description",
+    /** column name */
+    Features = "features",
+    /** column name */
+    Id = "id",
+    /** column name */
+    MonthlyCredits = "monthly_credits",
+    /** column name */
+    Name = "name",
+    /** column name */
+    PriceCents = "price_cents",
+    /** column name */
+    Slug = "slug",
+    /** column name */
+    SortOrder = "sort_order",
+    /** column name */
+    WhopPlanId = "whop_plan_id"
+}
+/** Streaming cursor of the table "plans" */
+export type Plans_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Plans_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Plans_Stream_Cursor_Value_Input = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    features?: InputMaybe<Scalars['jsonb']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    monthly_credits?: InputMaybe<Scalars['Int']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    price_cents?: InputMaybe<Scalars['Int']['input']>;
+    slug?: InputMaybe<Scalars['String']['input']>;
+    sort_order?: InputMaybe<Scalars['Int']['input']>;
+    whop_plan_id?: InputMaybe<Scalars['String']['input']>;
+};
+export type Query_Root = {
+    __typename?: 'query_root';
+    /** fetch data from the table: "affiliate_codes" */
+    affiliate_codes: Array<Affiliate_Codes>;
+    /** fetch data from the table: "affiliate_codes" using primary key columns */
+    affiliate_codes_by_pk?: Maybe<Affiliate_Codes>;
+    /** fetch data from the table: "affiliates" */
+    affiliates: Array<Affiliates>;
+    /** fetch data from the table: "affiliates" using primary key columns */
+    affiliates_by_pk?: Maybe<Affiliates>;
+    /** An array relationship */
+    assets: Array<Assets>;
+    /** An aggregate relationship */
+    assets_aggregate: Assets_Aggregate;
+    /** fetch data from the table: "assets" using primary key columns */
+    assets_by_pk?: Maybe<Assets>;
+    /** fetch data from the table: "credit_packs" */
+    credit_packs: Array<Credit_Packs>;
+    /** fetch data from the table: "credit_packs" using primary key columns */
+    credit_packs_by_pk?: Maybe<Credit_Packs>;
+    /** Get currently authenticated user from JWT claims */
+    current_user: Current_User_Output;
+    /** fetch data from the table: "executions_visibility" */
+    executions_visibility: Array<Executions_Visibility>;
+    /** Get user credit balance from TigerBeetle */
+    get_credit_balance?: Maybe<Credit_Balance_Output>;
+    /** Get user credit transaction history from TigerBeetle */
+    get_credit_history: Array<Credit_History_Entry>;
+    /** Get affiliate referral stats and referred users */
+    get_my_referrals: Get_My_Referrals_Output;
+    /** fetch data from the table: "personal_access_tokens" */
+    personal_access_tokens: Array<Personal_Access_Tokens>;
+    /** fetch data from the table: "personal_access_tokens" using primary key columns */
+    personal_access_tokens_by_pk?: Maybe<Personal_Access_Tokens>;
+    /** fetch data from the table: "pipeline_runs" */
+    pipeline_runs: Array<Pipeline_Runs>;
+    /** fetch aggregated fields from the table: "pipeline_runs" */
+    pipeline_runs_aggregate: Pipeline_Runs_Aggregate;
+    /** fetch data from the table: "pipeline_runs" using primary key columns */
+    pipeline_runs_by_pk?: Maybe<Pipeline_Runs>;
+    /** fetch data from the table: "pipelines" */
+    pipelines: Array<Pipelines>;
+    /** fetch data from the table: "pipelines" using primary key columns */
+    pipelines_by_pk?: Maybe<Pipelines>;
+    /** fetch data from the table: "plans" */
+    plans: Array<Plans>;
+    /** fetch data from the table: "plans" using primary key columns */
+    plans_by_pk?: Maybe<Plans>;
+    /** fetch data from the table: "subscriptions" */
+    subscriptions: Array<Subscriptions>;
+    /** fetch data from the table: "subscriptions" using primary key columns */
+    subscriptions_by_pk?: Maybe<Subscriptions>;
+};
+export type Query_RootAffiliate_CodesArgs = {
+    distinct_on?: InputMaybe<Array<Affiliate_Codes_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Affiliate_Codes_Order_By>>;
+    where?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+};
+export type Query_RootAffiliate_Codes_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootAffiliatesArgs = {
+    distinct_on?: InputMaybe<Array<Affiliates_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Affiliates_Order_By>>;
+    where?: InputMaybe<Affiliates_Bool_Exp>;
+};
+export type Query_RootAffiliates_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootAssetsArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+export type Query_RootAssets_AggregateArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+export type Query_RootAssets_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootCredit_PacksArgs = {
+    distinct_on?: InputMaybe<Array<Credit_Packs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Credit_Packs_Order_By>>;
+    where?: InputMaybe<Credit_Packs_Bool_Exp>;
+};
+export type Query_RootCredit_Packs_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootExecutions_VisibilityArgs = {
+    distinct_on?: InputMaybe<Array<Executions_Visibility_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Executions_Visibility_Order_By>>;
+    where?: InputMaybe<Executions_Visibility_Bool_Exp>;
+};
+export type Query_RootPersonal_Access_TokensArgs = {
+    distinct_on?: InputMaybe<Array<Personal_Access_Tokens_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Personal_Access_Tokens_Order_By>>;
+    where?: InputMaybe<Personal_Access_Tokens_Bool_Exp>;
+};
+export type Query_RootPersonal_Access_Tokens_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootPipeline_RunsArgs = {
+    distinct_on?: InputMaybe<Array<Pipeline_Runs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipeline_Runs_Order_By>>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+};
+export type Query_RootPipeline_Runs_AggregateArgs = {
+    distinct_on?: InputMaybe<Array<Pipeline_Runs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipeline_Runs_Order_By>>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+};
+export type Query_RootPipeline_Runs_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootPipelinesArgs = {
+    distinct_on?: InputMaybe<Array<Pipelines_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipelines_Order_By>>;
+    where?: InputMaybe<Pipelines_Bool_Exp>;
+};
+export type Query_RootPipelines_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootPlansArgs = {
+    distinct_on?: InputMaybe<Array<Plans_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Plans_Order_By>>;
+    where?: InputMaybe<Plans_Bool_Exp>;
+};
+export type Query_RootPlans_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Query_RootSubscriptionsArgs = {
+    distinct_on?: InputMaybe<Array<Subscriptions_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Subscriptions_Order_By>>;
+    where?: InputMaybe<Subscriptions_Bool_Exp>;
+};
+export type Query_RootSubscriptions_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Referral_Entry = {
+    __typename?: 'referral_entry';
+    commission_cents: Scalars['Int']['output'];
+    email: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    plan_name: Scalars['String']['output'];
+    signed_up_at: Scalars['String']['output'];
+    subscription_status: Scalars['String']['output'];
+    user_id: Scalars['String']['output'];
+};
+export type Request_Upload_Output = {
+    __typename?: 'request_upload_output';
+    asset_url: Scalars['String']['output'];
+    key: Scalars['String']['output'];
+    upload_url: Scalars['String']['output'];
+};
+export type Revoke_Personal_Access_Token_Output = {
+    __typename?: 'revoke_personal_access_token_output';
+    revoked_at: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+};
+export type Run_Pipeline_Output = {
+    __typename?: 'run_pipeline_output';
+    run_id: Scalars['String']['output'];
+    workflow_id: Scalars['String']['output'];
+};
+export type Social_Login_Output = {
+    __typename?: 'social_login_output';
+    redirect_url: Scalars['String']['output'];
+    success: Scalars['Boolean']['output'];
+};
+export type Subscription_Root = {
+    __typename?: 'subscription_root';
+    /** fetch data from the table: "affiliate_codes" */
+    affiliate_codes: Array<Affiliate_Codes>;
+    /** fetch data from the table: "affiliate_codes" using primary key columns */
+    affiliate_codes_by_pk?: Maybe<Affiliate_Codes>;
+    /** fetch data from the table in a streaming manner: "affiliate_codes" */
+    affiliate_codes_stream: Array<Affiliate_Codes>;
+    /** fetch data from the table: "affiliates" */
+    affiliates: Array<Affiliates>;
+    /** fetch data from the table: "affiliates" using primary key columns */
+    affiliates_by_pk?: Maybe<Affiliates>;
+    /** fetch data from the table in a streaming manner: "affiliates" */
+    affiliates_stream: Array<Affiliates>;
+    /** An array relationship */
+    assets: Array<Assets>;
+    /** An aggregate relationship */
+    assets_aggregate: Assets_Aggregate;
+    /** fetch data from the table: "assets" using primary key columns */
+    assets_by_pk?: Maybe<Assets>;
+    /** fetch data from the table in a streaming manner: "assets" */
+    assets_stream: Array<Assets>;
+    /** fetch data from the table: "credit_packs" */
+    credit_packs: Array<Credit_Packs>;
+    /** fetch data from the table: "credit_packs" using primary key columns */
+    credit_packs_by_pk?: Maybe<Credit_Packs>;
+    /** fetch data from the table in a streaming manner: "credit_packs" */
+    credit_packs_stream: Array<Credit_Packs>;
+    /** fetch data from the table: "executions_visibility" */
+    executions_visibility: Array<Executions_Visibility>;
+    /** fetch data from the table in a streaming manner: "executions_visibility" */
+    executions_visibility_stream: Array<Executions_Visibility>;
+    /** fetch data from the table: "personal_access_tokens" */
+    personal_access_tokens: Array<Personal_Access_Tokens>;
+    /** fetch data from the table: "personal_access_tokens" using primary key columns */
+    personal_access_tokens_by_pk?: Maybe<Personal_Access_Tokens>;
+    /** fetch data from the table in a streaming manner: "personal_access_tokens" */
+    personal_access_tokens_stream: Array<Personal_Access_Tokens>;
+    /** fetch data from the table: "pipeline_runs" */
+    pipeline_runs: Array<Pipeline_Runs>;
+    /** fetch aggregated fields from the table: "pipeline_runs" */
+    pipeline_runs_aggregate: Pipeline_Runs_Aggregate;
+    /** fetch data from the table: "pipeline_runs" using primary key columns */
+    pipeline_runs_by_pk?: Maybe<Pipeline_Runs>;
+    /** fetch data from the table in a streaming manner: "pipeline_runs" */
+    pipeline_runs_stream: Array<Pipeline_Runs>;
+    /** fetch data from the table: "pipelines" */
+    pipelines: Array<Pipelines>;
+    /** fetch data from the table: "pipelines" using primary key columns */
+    pipelines_by_pk?: Maybe<Pipelines>;
+    /** fetch data from the table in a streaming manner: "pipelines" */
+    pipelines_stream: Array<Pipelines>;
+    /** fetch data from the table: "plans" */
+    plans: Array<Plans>;
+    /** fetch data from the table: "plans" using primary key columns */
+    plans_by_pk?: Maybe<Plans>;
+    /** fetch data from the table in a streaming manner: "plans" */
+    plans_stream: Array<Plans>;
+    /** fetch data from the table: "subscriptions" */
+    subscriptions: Array<Subscriptions>;
+    /** fetch data from the table: "subscriptions" using primary key columns */
+    subscriptions_by_pk?: Maybe<Subscriptions>;
+    /** fetch data from the table in a streaming manner: "subscriptions" */
+    subscriptions_stream: Array<Subscriptions>;
+};
+export type Subscription_RootAffiliate_CodesArgs = {
+    distinct_on?: InputMaybe<Array<Affiliate_Codes_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Affiliate_Codes_Order_By>>;
+    where?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+};
+export type Subscription_RootAffiliate_Codes_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootAffiliate_Codes_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Affiliate_Codes_Stream_Cursor_Input>>;
+    where?: InputMaybe<Affiliate_Codes_Bool_Exp>;
+};
+export type Subscription_RootAffiliatesArgs = {
+    distinct_on?: InputMaybe<Array<Affiliates_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Affiliates_Order_By>>;
+    where?: InputMaybe<Affiliates_Bool_Exp>;
+};
+export type Subscription_RootAffiliates_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootAffiliates_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Affiliates_Stream_Cursor_Input>>;
+    where?: InputMaybe<Affiliates_Bool_Exp>;
+};
+export type Subscription_RootAssetsArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+export type Subscription_RootAssets_AggregateArgs = {
+    distinct_on?: InputMaybe<Array<Assets_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Assets_Order_By>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+export type Subscription_RootAssets_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootAssets_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Assets_Stream_Cursor_Input>>;
+    where?: InputMaybe<Assets_Bool_Exp>;
+};
+export type Subscription_RootCredit_PacksArgs = {
+    distinct_on?: InputMaybe<Array<Credit_Packs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Credit_Packs_Order_By>>;
+    where?: InputMaybe<Credit_Packs_Bool_Exp>;
+};
+export type Subscription_RootCredit_Packs_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootCredit_Packs_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Credit_Packs_Stream_Cursor_Input>>;
+    where?: InputMaybe<Credit_Packs_Bool_Exp>;
+};
+export type Subscription_RootExecutions_VisibilityArgs = {
+    distinct_on?: InputMaybe<Array<Executions_Visibility_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Executions_Visibility_Order_By>>;
+    where?: InputMaybe<Executions_Visibility_Bool_Exp>;
+};
+export type Subscription_RootExecutions_Visibility_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Executions_Visibility_Stream_Cursor_Input>>;
+    where?: InputMaybe<Executions_Visibility_Bool_Exp>;
+};
+export type Subscription_RootPersonal_Access_TokensArgs = {
+    distinct_on?: InputMaybe<Array<Personal_Access_Tokens_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Personal_Access_Tokens_Order_By>>;
+    where?: InputMaybe<Personal_Access_Tokens_Bool_Exp>;
+};
+export type Subscription_RootPersonal_Access_Tokens_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootPersonal_Access_Tokens_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Personal_Access_Tokens_Stream_Cursor_Input>>;
+    where?: InputMaybe<Personal_Access_Tokens_Bool_Exp>;
+};
+export type Subscription_RootPipeline_RunsArgs = {
+    distinct_on?: InputMaybe<Array<Pipeline_Runs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipeline_Runs_Order_By>>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+};
+export type Subscription_RootPipeline_Runs_AggregateArgs = {
+    distinct_on?: InputMaybe<Array<Pipeline_Runs_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipeline_Runs_Order_By>>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+};
+export type Subscription_RootPipeline_Runs_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootPipeline_Runs_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Pipeline_Runs_Stream_Cursor_Input>>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+};
+export type Subscription_RootPipelinesArgs = {
+    distinct_on?: InputMaybe<Array<Pipelines_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Pipelines_Order_By>>;
+    where?: InputMaybe<Pipelines_Bool_Exp>;
+};
+export type Subscription_RootPipelines_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootPipelines_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Pipelines_Stream_Cursor_Input>>;
+    where?: InputMaybe<Pipelines_Bool_Exp>;
+};
+export type Subscription_RootPlansArgs = {
+    distinct_on?: InputMaybe<Array<Plans_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Plans_Order_By>>;
+    where?: InputMaybe<Plans_Bool_Exp>;
+};
+export type Subscription_RootPlans_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootPlans_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Plans_Stream_Cursor_Input>>;
+    where?: InputMaybe<Plans_Bool_Exp>;
+};
+export type Subscription_RootSubscriptionsArgs = {
+    distinct_on?: InputMaybe<Array<Subscriptions_Select_Column>>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    order_by?: InputMaybe<Array<Subscriptions_Order_By>>;
+    where?: InputMaybe<Subscriptions_Bool_Exp>;
+};
+export type Subscription_RootSubscriptions_By_PkArgs = {
+    id: Scalars['uuid']['input'];
+};
+export type Subscription_RootSubscriptions_StreamArgs = {
+    batch_size: Scalars['Int']['input'];
+    cursor: Array<InputMaybe<Subscriptions_Stream_Cursor_Input>>;
+    where?: InputMaybe<Subscriptions_Bool_Exp>;
+};
+/** columns and relationships of "subscriptions" */
+export type Subscriptions = {
+    __typename?: 'subscriptions';
+    cancel_at_period_end: Scalars['Boolean']['output'];
+    created_at: Scalars['timestamptz']['output'];
+    id: Scalars['uuid']['output'];
+    period_end: Scalars['timestamptz']['output'];
+    period_start: Scalars['timestamptz']['output'];
+    /** An object relationship */
+    plan: Plans;
+    plan_id: Scalars['uuid']['output'];
+    status: Scalars['String']['output'];
+};
+/** Boolean expression to filter rows from the table "subscriptions". All fields are combined with a logical 'AND'. */
+export type Subscriptions_Bool_Exp = {
+    _and?: InputMaybe<Array<Subscriptions_Bool_Exp>>;
+    _not?: InputMaybe<Subscriptions_Bool_Exp>;
+    _or?: InputMaybe<Array<Subscriptions_Bool_Exp>>;
+    cancel_at_period_end?: InputMaybe<Boolean_Comparison_Exp>;
+    created_at?: InputMaybe<Timestamptz_Comparison_Exp>;
+    id?: InputMaybe<Uuid_Comparison_Exp>;
+    period_end?: InputMaybe<Timestamptz_Comparison_Exp>;
+    period_start?: InputMaybe<Timestamptz_Comparison_Exp>;
+    plan?: InputMaybe<Plans_Bool_Exp>;
+    plan_id?: InputMaybe<Uuid_Comparison_Exp>;
+    status?: InputMaybe<String_Comparison_Exp>;
+};
+/** Ordering options when selecting data from "subscriptions". */
+export type Subscriptions_Order_By = {
+    cancel_at_period_end?: InputMaybe<Order_By>;
+    created_at?: InputMaybe<Order_By>;
+    id?: InputMaybe<Order_By>;
+    period_end?: InputMaybe<Order_By>;
+    period_start?: InputMaybe<Order_By>;
+    plan?: InputMaybe<Plans_Order_By>;
+    plan_id?: InputMaybe<Order_By>;
+    status?: InputMaybe<Order_By>;
+};
+/** select columns of table "subscriptions" */
+export declare enum Subscriptions_Select_Column {
+    /** column name */
+    CancelAtPeriodEnd = "cancel_at_period_end",
+    /** column name */
+    CreatedAt = "created_at",
+    /** column name */
+    Id = "id",
+    /** column name */
+    PeriodEnd = "period_end",
+    /** column name */
+    PeriodStart = "period_start",
+    /** column name */
+    PlanId = "plan_id",
+    /** column name */
+    Status = "status"
+}
+/** Streaming cursor of the table "subscriptions" */
+export type Subscriptions_Stream_Cursor_Input = {
+    /** Stream column input with initial value */
+    initial_value: Subscriptions_Stream_Cursor_Value_Input;
+    /** cursor ordering */
+    ordering?: InputMaybe<Cursor_Ordering>;
+};
+/** Initial value of the column from where the streaming should start */
+export type Subscriptions_Stream_Cursor_Value_Input = {
+    cancel_at_period_end?: InputMaybe<Scalars['Boolean']['input']>;
+    created_at?: InputMaybe<Scalars['timestamptz']['input']>;
+    id?: InputMaybe<Scalars['uuid']['input']>;
+    period_end?: InputMaybe<Scalars['timestamptz']['input']>;
+    period_start?: InputMaybe<Scalars['timestamptz']['input']>;
+    plan_id?: InputMaybe<Scalars['uuid']['input']>;
+    status?: InputMaybe<Scalars['String']['input']>;
+};
+/** Boolean expression to compare columns of type "timestamp". All fields are combined with logical 'AND'. */
+export type Timestamp_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['timestamp']['input']>;
+    _gt?: InputMaybe<Scalars['timestamp']['input']>;
+    _gte?: InputMaybe<Scalars['timestamp']['input']>;
+    _in?: InputMaybe<Array<Scalars['timestamp']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['timestamp']['input']>;
+    _lte?: InputMaybe<Scalars['timestamp']['input']>;
+    _neq?: InputMaybe<Scalars['timestamp']['input']>;
+    _nin?: InputMaybe<Array<Scalars['timestamp']['input']>>;
+};
+/** Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'. */
+export type Timestamptz_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['timestamptz']['input']>;
+    _gt?: InputMaybe<Scalars['timestamptz']['input']>;
+    _gte?: InputMaybe<Scalars['timestamptz']['input']>;
+    _in?: InputMaybe<Array<Scalars['timestamptz']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['timestamptz']['input']>;
+    _lte?: InputMaybe<Scalars['timestamptz']['input']>;
+    _neq?: InputMaybe<Scalars['timestamptz']['input']>;
+    _nin?: InputMaybe<Array<Scalars['timestamptz']['input']>>;
+};
+/** Boolean expression to compare columns of type "uuid". All fields are combined with logical 'AND'. */
+export type Uuid_Comparison_Exp = {
+    _eq?: InputMaybe<Scalars['uuid']['input']>;
+    _gt?: InputMaybe<Scalars['uuid']['input']>;
+    _gte?: InputMaybe<Scalars['uuid']['input']>;
+    _in?: InputMaybe<Array<Scalars['uuid']['input']>>;
+    _is_null?: InputMaybe<Scalars['Boolean']['input']>;
+    _lt?: InputMaybe<Scalars['uuid']['input']>;
+    _lte?: InputMaybe<Scalars['uuid']['input']>;
+    _neq?: InputMaybe<Scalars['uuid']['input']>;
+    _nin?: InputMaybe<Array<Scalars['uuid']['input']>>;
+};
+export type GetMyAffiliateCodesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetMyAffiliateCodesQuery = {
+    __typename?: 'query_root';
+    affiliate_codes: Array<{
+        __typename?: 'affiliate_codes';
+        id: any;
+        code: string;
+        is_primary?: boolean | null;
+        redirect_path?: string | null;
+        created_at?: any | null;
+    }>;
+};
+export type GetMyAffiliateQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetMyAffiliateQuery = {
+    __typename?: 'query_root';
+    affiliates: Array<{
+        __typename?: 'affiliates';
+        id: any;
+        whop_affiliate_id?: string | null;
+        commission_percent?: number | null;
+        is_active?: boolean | null;
+        codes: Array<{
+            __typename?: 'affiliate_codes';
+            id: any;
+            code: string;
+            is_primary?: boolean | null;
+            redirect_path?: string | null;
+            created_at?: any | null;
+        }>;
+    }>;
+};
+export type AddAffiliateCodeMutationVariables = Exact<{
+    code: Scalars['String']['input'];
+    redirect_path?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type AddAffiliateCodeMutation = {
+    __typename?: 'mutation_root';
+    add_affiliate_code: {
+        __typename?: 'add_affiliate_code_output';
+        success: boolean;
+        code_id: string;
+    };
+};
+export type EnsureAffiliateMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type EnsureAffiliateMutation = {
+    __typename?: 'mutation_root';
+    ensure_affiliate: {
+        __typename?: 'ensure_affiliate_output';
+        success: boolean;
+        affiliate_id: string;
+    };
+};
+export type GetMyReferralsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetMyReferralsQuery = {
+    __typename?: 'query_root';
+    get_my_referrals: {
+        __typename?: 'get_my_referrals_output';
+        total_referrals: number;
+        active_referrals: number;
+        total_commission_cents: number;
+        referrals: Array<{
+            __typename?: 'referral_entry';
+            user_id: string;
+            email: string;
+            name: string;
+            signed_up_at: string;
+            subscription_status: string;
+            plan_name: string;
+            commission_cents: number;
+        }>;
+    };
+};
+export type GetUserAssetsQueryVariables = Exact<{
+    where?: InputMaybe<Assets_Bool_Exp>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type GetUserAssetsQuery = {
+    __typename?: 'query_root';
+    assets: Array<{
+        __typename?: 'assets';
+        id: any;
+        type: string;
+        url: string;
+        thumbnail_url?: string | null;
+        metadata?: any | null;
+        tags: Array<string>;
+        created_at: any;
+        pipeline_run_id?: any | null;
+    }>;
+    assets_aggregate: {
+        __typename?: 'assets_aggregate';
+        aggregate?: {
+            __typename?: 'assets_aggregate_fields';
+            count: number;
+        } | null;
+    };
+};
+export type RequestUploadMutationVariables = Exact<{
+    filename: Scalars['String']['input'];
+    content_type: Scalars['String']['input'];
+}>;
+export type RequestUploadMutation = {
+    __typename?: 'mutation_root';
+    request_upload: {
+        __typename?: 'request_upload_output';
+        upload_url: string;
+        asset_url: string;
+        key: string;
+    };
+};
+export type CreateAssetMutationVariables = Exact<{
+    asset_type: Scalars['String']['input'];
+    url: Scalars['String']['input'];
+    tags?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
+}>;
+export type CreateAssetMutation = {
+    __typename?: 'mutation_root';
+    create_asset: {
+        __typename?: 'create_asset_output';
+        id: string;
+        type: string;
+        url: string;
+        tags: Array<string>;
+        created_at: string;
+    };
+};
+export type DeleteAssetActionMutationVariables = Exact<{
+    id: Scalars['uuid']['input'];
+}>;
+export type DeleteAssetActionMutation = {
+    __typename?: 'mutation_root';
+    delete_asset: {
+        __typename?: 'delete_asset_output';
+        success: boolean;
+    };
+};
+export type UpdateAssetTagsMutationVariables = Exact<{
+    id: Scalars['uuid']['input'];
+    tags: Array<Scalars['String']['input']> | Scalars['String']['input'];
+}>;
+export type UpdateAssetTagsMutation = {
+    __typename?: 'mutation_root';
+    update_assets_by_pk?: {
+        __typename?: 'assets';
+        id: any;
+        tags: Array<string>;
+    } | null;
+};
+export type InitLoginFlowMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type InitLoginFlowMutation = {
+    __typename?: 'mutation_root';
+    init_login_flow: {
+        __typename?: 'auth_flow';
+        id: string;
+        csrf_token: string;
+    };
+};
+export type SubmitLoginFlowMutationVariables = Exact<{
+    flowId: Scalars['String']['input'];
+    email: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    csrf_token: Scalars['String']['input'];
+    referral_code?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type SubmitLoginFlowMutation = {
+    __typename?: 'mutation_root';
+    submit_login_flow: {
+        __typename?: 'auth_result';
+        success: boolean;
+        message: string;
+        token?: string | null;
+        whop_affiliate_id?: string | null;
+    };
+};
+export type InitSignupFlowMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type InitSignupFlowMutation = {
+    __typename?: 'mutation_root';
+    init_signup_flow: {
+        __typename?: 'auth_flow';
+        id: string;
+        csrf_token: string;
+    };
+};
+export type SubmitSignupFlowMutationVariables = Exact<{
+    flowId: Scalars['String']['input'];
+    email: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    csrf_token: Scalars['String']['input'];
+}>;
+export type SubmitSignupFlowMutation = {
+    __typename?: 'mutation_root';
+    submit_signup_flow: {
+        __typename?: 'auth_result';
+        success: boolean;
+        message: string;
+        token?: string | null;
+    };
+};
+export type SubmitSocialLoginMutationVariables = Exact<{
+    provider: Scalars['String']['input'];
+}>;
+export type SubmitSocialLoginMutation = {
+    __typename?: 'mutation_root';
+    submit_social_login: {
+        __typename?: 'social_login_output';
+        success: boolean;
+        redirect_url: string;
+    };
+};
+export type InitVerificationFlowMutationVariables = Exact<{
+    email?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type InitVerificationFlowMutation = {
+    __typename?: 'mutation_root';
+    init_verification_flow: {
+        __typename?: 'auth_flow';
+        id: string;
+        csrf_token: string;
+    };
+};
+export type SubmitVerificationCodeMutationVariables = Exact<{
+    flowId: Scalars['String']['input'];
+    code: Scalars['String']['input'];
+    csrf_token: Scalars['String']['input'];
+}>;
+export type SubmitVerificationCodeMutation = {
+    __typename?: 'mutation_root';
+    submit_verification_code: {
+        __typename?: 'auth_result';
+        success: boolean;
+        message: string;
+    };
+};
+export type InitRecoveryFlowMutationVariables = Exact<{
+    email: Scalars['String']['input'];
+}>;
+export type InitRecoveryFlowMutation = {
+    __typename?: 'mutation_root';
+    init_recovery_flow: {
+        __typename?: 'auth_result';
+        success: boolean;
+        message: string;
+    };
+};
+export type SubmitRecoveryFlowMutationVariables = Exact<{
+    flowId: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    csrf_token: Scalars['String']['input'];
+}>;
+export type SubmitRecoveryFlowMutation = {
+    __typename?: 'mutation_root';
+    submit_recovery_flow: {
+        __typename?: 'auth_result';
+        success: boolean;
+        message: string;
+    };
+};
+export type GetCreditBalanceQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCreditBalanceQuery = {
+    __typename?: 'query_root';
+    get_credit_balance?: {
+        __typename?: 'credit_balance_output';
+        balance: number;
+        reserved: number;
+        available: number;
+    } | null;
+};
+export type GetCreditHistoryQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCreditHistoryQuery = {
+    __typename?: 'query_root';
+    get_credit_history: Array<{
+        __typename?: 'credit_history_entry';
+        type: string;
+        amount: number;
+        description: string;
+        created_at: string;
+    }>;
+};
+export type GetPipelinesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetPipelinesQuery = {
+    __typename?: 'query_root';
+    pipelines: Array<{
+        __typename?: 'pipelines';
+        id: any;
+        slug: string;
+        name: string;
+        description?: string | null;
+        category: string;
+        icon_url?: string | null;
+        preview_url?: string | null;
+        required_providers: Array<string>;
+        credit_cost: number;
+        input_schema: any;
+        ui_schema: any;
+        output_schema: any;
+        seo_content?: string | null;
+        seo_faq?: any | null;
+    }>;
+};
+export type RunPipelineMutationVariables = Exact<{
+    pipeline_slug: Scalars['String']['input'];
+    input: Scalars['jsonb']['input'];
+}>;
+export type RunPipelineMutation = {
+    __typename?: 'mutation_root';
+    run_pipeline?: {
+        __typename?: 'run_pipeline_output';
+        run_id: string;
+        workflow_id: string;
+    } | null;
+};
+export type GetPipelineRunQueryVariables = Exact<{
+    id: Scalars['uuid']['input'];
+}>;
+export type GetPipelineRunQuery = {
+    __typename?: 'query_root';
+    pipeline_runs_by_pk?: {
+        __typename?: 'pipeline_runs';
+        id: any;
+        status: string;
+        output?: any | null;
+        error_message?: string | null;
+        credits_charged?: number | null;
+        created_at: any;
+        completed_at?: any | null;
+        pipeline: {
+            __typename?: 'pipelines';
+            name: string;
+            slug: string;
+            output_schema: any;
+        };
+        assets: Array<{
+            __typename?: 'assets';
+            id: any;
+            type: string;
+            url: string;
+            thumbnail_url?: string | null;
+            created_at: any;
+        }>;
+        workflow_execution?: {
+            __typename?: 'executions_visibility';
+            status: number;
+            start_time: any;
+            close_time?: any | null;
+        } | null;
+    } | null;
+};
+export type GetPipelineRunsQueryVariables = Exact<{
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<Pipeline_Runs_Bool_Exp>;
+}>;
+export type GetPipelineRunsQuery = {
+    __typename?: 'query_root';
+    pipeline_runs: Array<{
+        __typename?: 'pipeline_runs';
+        id: any;
+        status: string;
+        output?: any | null;
+        error_message?: string | null;
+        credits_charged?: number | null;
+        created_at: any;
+        completed_at?: any | null;
+        pipeline: {
+            __typename?: 'pipelines';
+            name: string;
+            slug: string;
+            output_schema: any;
+        };
+    }>;
+    pipeline_runs_aggregate: {
+        __typename?: 'pipeline_runs_aggregate';
+        aggregate?: {
+            __typename?: 'pipeline_runs_aggregate_fields';
+            count: number;
+            sum?: {
+                __typename?: 'pipeline_runs_sum_fields';
+                credits_charged?: number | null;
+            } | null;
+        } | null;
+    };
+    completed: {
+        __typename?: 'pipeline_runs_aggregate';
+        aggregate?: {
+            __typename?: 'pipeline_runs_aggregate_fields';
+            count: number;
+        } | null;
+    };
+};
+export type GetPipelineRunsBySlugQueryVariables = Exact<{
+    slug: Scalars['String']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type GetPipelineRunsBySlugQuery = {
+    __typename?: 'query_root';
+    pipeline_runs: Array<{
+        __typename?: 'pipeline_runs';
+        id: any;
+        status: string;
+        output?: any | null;
+        error_message?: string | null;
+        credits_charged?: number | null;
+        created_at: any;
+        completed_at?: any | null;
+        pipeline: {
+            __typename?: 'pipelines';
+            name: string;
+            slug: string;
+            output_schema: any;
+        };
+        workflow_execution?: {
+            __typename?: 'executions_visibility';
+            status: number;
+            start_time: any;
+            close_time?: any | null;
+        } | null;
+    }>;
+    pipeline_runs_aggregate: {
+        __typename?: 'pipeline_runs_aggregate';
+        aggregate?: {
+            __typename?: 'pipeline_runs_aggregate_fields';
+            count: number;
+        } | null;
+    };
+};
+export type GetPlansQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetPlansQuery = {
+    __typename?: 'query_root';
+    plans: Array<{
+        __typename?: 'plans';
+        id: any;
+        slug: string;
+        name: string;
+        description?: string | null;
+        monthly_credits: number;
+        price_cents: number;
+        features: any;
+        sort_order: number;
+        whop_plan_id?: string | null;
+    }>;
+};
+export type GetCreditPacksQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCreditPacksQuery = {
+    __typename?: 'query_root';
+    credit_packs: Array<{
+        __typename?: 'credit_packs';
+        id: any;
+        slug: string;
+        name: string;
+        credits: number;
+        price_cents: number;
+        sort_order: number;
+        whop_plan_id?: string | null;
+    }>;
+};
+export type GetSubscriptionQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetSubscriptionQuery = {
+    __typename?: 'query_root';
+    subscriptions: Array<{
+        __typename?: 'subscriptions';
+        id: any;
+        plan_id: any;
+        status: string;
+        period_start: any;
+        period_end: any;
+        cancel_at_period_end: boolean;
+        plan: {
+            __typename?: 'plans';
+            slug: string;
+            name: string;
+            monthly_credits: number;
+            sort_order: number;
+        };
+    }>;
+};
+export type WatchPipelineRunSubscriptionVariables = Exact<{
+    run_id: Scalars['uuid']['input'];
+}>;
+export type WatchPipelineRunSubscription = {
+    __typename?: 'subscription_root';
+    pipeline_runs_by_pk?: {
+        __typename?: 'pipeline_runs';
+        id: any;
+        status: string;
+        output?: any | null;
+        error_message?: string | null;
+        completed_at?: any | null;
+        pipeline: {
+            __typename?: 'pipelines';
+            name: string;
+            slug: string;
+        };
+        assets: Array<{
+            __typename?: 'assets';
+            id: any;
+            type: string;
+            url: string;
+            thumbnail_url?: string | null;
+        }>;
+    } | null;
+};
+export type GetMyApiKeysQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetMyApiKeysQuery = {
+    __typename?: 'query_root';
+    personal_access_tokens: Array<{
+        __typename?: 'personal_access_tokens';
+        id: any;
+        name: string;
+        scopes: Array<string>;
+        last_used_at?: any | null;
+        created_at: any;
+        expires_at: any;
+        revoked_at?: any | null;
+    }>;
+};
+export type CreatePersonalAccessTokenMutationVariables = Exact<{
+    name: Scalars['String']['input'];
+}>;
+export type CreatePersonalAccessTokenMutation = {
+    __typename?: 'mutation_root';
+    create_personal_access_token: {
+        __typename?: 'create_personal_access_token_output';
+        success: boolean;
+        id: string;
+        token: string;
+        jti: string;
+        expires_at: string;
+    };
+};
+export type RevokePersonalAccessTokenMutationVariables = Exact<{
+    id: Scalars['uuid']['input'];
+}>;
+export type RevokePersonalAccessTokenMutation = {
+    __typename?: 'mutation_root';
+    revoke_personal_access_token: {
+        __typename?: 'revoke_personal_access_token_output';
+        success: boolean;
+        revoked_at: string;
+    };
+};
+export type GetCurrentUserQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCurrentUserQuery = {
+    __typename?: 'query_root';
+    current_user: {
+        __typename?: 'current_user_output';
+        id: string;
+        email: string;
+        name: string;
+        email_verified: boolean;
+        avatar_url?: string | null;
+    };
+};
+export declare const GetMyAffiliateCodesDocument: DocumentNode;
+export declare const GetMyAffiliateDocument: DocumentNode;
+export declare const AddAffiliateCodeDocument: DocumentNode;
+export declare const EnsureAffiliateDocument: DocumentNode;
+export declare const GetMyReferralsDocument: DocumentNode;
+export declare const GetUserAssetsDocument: DocumentNode;
+export declare const RequestUploadDocument: DocumentNode;
+export declare const CreateAssetDocument: DocumentNode;
+export declare const DeleteAssetActionDocument: DocumentNode;
+export declare const UpdateAssetTagsDocument: DocumentNode;
+export declare const InitLoginFlowDocument: DocumentNode;
+export declare const SubmitLoginFlowDocument: DocumentNode;
+export declare const InitSignupFlowDocument: DocumentNode;
+export declare const SubmitSignupFlowDocument: DocumentNode;
+export declare const SubmitSocialLoginDocument: DocumentNode;
+export declare const InitVerificationFlowDocument: DocumentNode;
+export declare const SubmitVerificationCodeDocument: DocumentNode;
+export declare const InitRecoveryFlowDocument: DocumentNode;
+export declare const SubmitRecoveryFlowDocument: DocumentNode;
+export declare const GetCreditBalanceDocument: DocumentNode;
+export declare const GetCreditHistoryDocument: DocumentNode;
+export declare const GetPipelinesDocument: DocumentNode;
+export declare const RunPipelineDocument: DocumentNode;
+export declare const GetPipelineRunDocument: DocumentNode;
+export declare const GetPipelineRunsDocument: DocumentNode;
+export declare const GetPipelineRunsBySlugDocument: DocumentNode;
+export declare const GetPlansDocument: DocumentNode;
+export declare const GetCreditPacksDocument: DocumentNode;
+export declare const GetSubscriptionDocument: DocumentNode;
+export declare const WatchPipelineRunDocument: DocumentNode;
+export declare const GetMyApiKeysDocument: DocumentNode;
+export declare const CreatePersonalAccessTokenDocument: DocumentNode;
+export declare const RevokePersonalAccessTokenDocument: DocumentNode;
+export declare const GetCurrentUserDocument: DocumentNode;
+export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
+export declare function getSdk<C>(requester: Requester<C>): {
+    GetMyAffiliateCodes(variables?: GetMyAffiliateCodesQueryVariables, options?: C): Promise<GetMyAffiliateCodesQuery>;
+    GetMyAffiliate(variables?: GetMyAffiliateQueryVariables, options?: C): Promise<GetMyAffiliateQuery>;
+    AddAffiliateCode(variables: AddAffiliateCodeMutationVariables, options?: C): Promise<AddAffiliateCodeMutation>;
+    EnsureAffiliate(variables?: EnsureAffiliateMutationVariables, options?: C): Promise<EnsureAffiliateMutation>;
+    GetMyReferrals(variables?: GetMyReferralsQueryVariables, options?: C): Promise<GetMyReferralsQuery>;
+    GetUserAssets(variables?: GetUserAssetsQueryVariables, options?: C): Promise<GetUserAssetsQuery>;
+    RequestUpload(variables: RequestUploadMutationVariables, options?: C): Promise<RequestUploadMutation>;
+    CreateAsset(variables: CreateAssetMutationVariables, options?: C): Promise<CreateAssetMutation>;
+    DeleteAssetAction(variables: DeleteAssetActionMutationVariables, options?: C): Promise<DeleteAssetActionMutation>;
+    UpdateAssetTags(variables: UpdateAssetTagsMutationVariables, options?: C): Promise<UpdateAssetTagsMutation>;
+    InitLoginFlow(variables?: InitLoginFlowMutationVariables, options?: C): Promise<InitLoginFlowMutation>;
+    SubmitLoginFlow(variables: SubmitLoginFlowMutationVariables, options?: C): Promise<SubmitLoginFlowMutation>;
+    InitSignupFlow(variables?: InitSignupFlowMutationVariables, options?: C): Promise<InitSignupFlowMutation>;
+    SubmitSignupFlow(variables: SubmitSignupFlowMutationVariables, options?: C): Promise<SubmitSignupFlowMutation>;
+    SubmitSocialLogin(variables: SubmitSocialLoginMutationVariables, options?: C): Promise<SubmitSocialLoginMutation>;
+    InitVerificationFlow(variables?: InitVerificationFlowMutationVariables, options?: C): Promise<InitVerificationFlowMutation>;
+    SubmitVerificationCode(variables: SubmitVerificationCodeMutationVariables, options?: C): Promise<SubmitVerificationCodeMutation>;
+    InitRecoveryFlow(variables: InitRecoveryFlowMutationVariables, options?: C): Promise<InitRecoveryFlowMutation>;
+    SubmitRecoveryFlow(variables: SubmitRecoveryFlowMutationVariables, options?: C): Promise<SubmitRecoveryFlowMutation>;
+    GetCreditBalance(variables?: GetCreditBalanceQueryVariables, options?: C): Promise<GetCreditBalanceQuery>;
+    GetCreditHistory(variables?: GetCreditHistoryQueryVariables, options?: C): Promise<GetCreditHistoryQuery>;
+    GetPipelines(variables?: GetPipelinesQueryVariables, options?: C): Promise<GetPipelinesQuery>;
+    RunPipeline(variables: RunPipelineMutationVariables, options?: C): Promise<RunPipelineMutation>;
+    GetPipelineRun(variables: GetPipelineRunQueryVariables, options?: C): Promise<GetPipelineRunQuery>;
+    GetPipelineRuns(variables?: GetPipelineRunsQueryVariables, options?: C): Promise<GetPipelineRunsQuery>;
+    GetPipelineRunsBySlug(variables: GetPipelineRunsBySlugQueryVariables, options?: C): Promise<GetPipelineRunsBySlugQuery>;
+    GetPlans(variables?: GetPlansQueryVariables, options?: C): Promise<GetPlansQuery>;
+    GetCreditPacks(variables?: GetCreditPacksQueryVariables, options?: C): Promise<GetCreditPacksQuery>;
+    GetSubscription(variables?: GetSubscriptionQueryVariables, options?: C): Promise<GetSubscriptionQuery>;
+    WatchPipelineRun(variables: WatchPipelineRunSubscriptionVariables, options?: C): AsyncIterable<WatchPipelineRunSubscription>;
+    GetMyApiKeys(variables?: GetMyApiKeysQueryVariables, options?: C): Promise<GetMyApiKeysQuery>;
+    CreatePersonalAccessToken(variables: CreatePersonalAccessTokenMutationVariables, options?: C): Promise<CreatePersonalAccessTokenMutation>;
+    RevokePersonalAccessToken(variables: RevokePersonalAccessTokenMutationVariables, options?: C): Promise<RevokePersonalAccessTokenMutation>;
+    GetCurrentUser(variables?: GetCurrentUserQueryVariables, options?: C): Promise<GetCurrentUserQuery>;
+};
+export type Sdk = ReturnType<typeof getSdk>;